#! /bin/sh
# Generated from ../../../src/matio/test/testsuite.at by GNU Autoconf 2.68.
#
# Copyright (C) 2009, 2010 Free Software Foundation, Inc.
#
# This test suite is free software; the Free Software Foundation gives
# unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##

# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '${1+"$@"}'='"$@"'
  setopt NO_GLOB_SUBST
else
  case `(set -o) 2>/dev/null` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi


as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='print -r --'
  as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
  as_echo='printf %s\n'
  as_echo_n='printf %s'
else
  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
    as_echo_n='/usr/ucb/echo -n'
  else
    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
    as_echo_n_body='eval
      arg=$1;
      case $arg in #(
      *"$as_nl"*)
	expr "X$arg" : "X\\(.*\\)$as_nl";
	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
      esac;
      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
    '
    export as_echo_n_body
    as_echo_n='sh -c $as_echo_n_body as_echo'
  fi
  export as_echo_body
  as_echo='sh -c $as_echo_body as_echo'
fi

# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
  PATH_SEPARATOR=:
  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
      PATH_SEPARATOR=';'
  }
fi


# IFS
# We need space, tab and new line, in precisely that order.  Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" ""	$as_nl"

# Find who we are.  Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
  *[\\/]* ) as_myself=$0 ;;
  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
  done
IFS=$as_save_IFS

     ;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
  as_myself=$0
fi
if test ! -f "$as_myself"; then
  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
  exit 1
fi

# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there.  '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '

# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE

# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

if test "x$CONFIG_SHELL" = x; then
  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
  emulate sh
  NULLCMD=:
  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
  # is contrary to our usage.  Disable this feature.
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
  setopt NO_GLOB_SUBST
else
  case \`(set -o) 2>/dev/null\` in #(
  *posix*) :
    set -o posix ;; #(
  *) :
     ;;
esac
fi
"
  as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }

exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :

else
  exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1"
  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
  if (eval "$as_required") 2>/dev/null; then :
  as_have_required=yes
else
  as_have_required=no
fi
  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :

else
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
  as_found=:
  case $as_dir in #(
	 /*)
	   for as_base in sh bash ksh sh5; do
	     # Try only shells that exist, to save several forks.
	     as_shell=$as_dir/$as_base
	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
  CONFIG_SHELL=$as_shell as_have_required=yes
		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
  break 2
fi
fi
	   done;;
       esac
  as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
  CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS


      if test "x$CONFIG_SHELL" != x; then :
  # We cannot yet assume a decent shell, so we have to provide a
	# neutralization value for shells without unset; and this also
	# works around shells that cannot unset nonexistent variables.
	# Preserve -v and -x to the replacement shell.
	BASH_ENV=/dev/null
	ENV=/dev/null
	(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
	export CONFIG_SHELL
	case $- in # ((((
	  *v*x* | *x*v* ) as_opts=-vx ;;
	  *v* ) as_opts=-v ;;
	  *x* ) as_opts=-x ;;
	  * ) as_opts= ;;
	esac
	exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
fi

    if test x$as_have_required = xno; then :
  $as_echo "$0: This script requires a shell more modern than all"
  $as_echo "$0: the shells that I found on your system."
  if test x${ZSH_VERSION+set} = xset ; then
    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
  else
    $as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
$0: including any error possibly output before this
$0: message. Then install a modern shell, or manually run
$0: the script under such a shell if you do have one."
  fi
  exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS

## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
  { eval $1=; unset $1;}
}
as_unset=as_fn_unset

# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
  return $1
} # as_fn_set_status

# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
  set +e
  as_fn_set_status $1
  exit $1
} # as_fn_exit

# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{

  case $as_dir in #(
  -*) as_dir=./$as_dir;;
  esac
  test -d "$as_dir" || eval $as_mkdir_p || {
    as_dirs=
    while :; do
      case $as_dir in #(
      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
      *) as_qdir=$as_dir;;
      esac
      as_dirs="'$as_qdir' $as_dirs"
      as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
	 X"$as_dir" : 'X\(//\)[^/]' \| \
	 X"$as_dir" : 'X\(//\)$' \| \
	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)[^/].*/{
	    s//\1/
	    q
	  }
	  /^X\(\/\/\)$/{
	    s//\1/
	    q
	  }
	  /^X\(\/\).*/{
	    s//\1/
	    q
	  }
	  s/.*/./; q'`
      test -d "$as_dir" && break
    done
    test -z "$as_dirs" || eval "mkdir $as_dirs"
  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"


} # as_fn_mkdir_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
  eval 'as_fn_append ()
  {
    eval $1+=\$2
  }'
else
  as_fn_append ()
  {
    eval $1=\$$1\$2
  }
fi # as_fn_append

# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
  eval 'as_fn_arith ()
  {
    as_val=$(( $* ))
  }'
else
  as_fn_arith ()
  {
    as_val=`expr "$@" || test $? -eq 1`
  }
fi # as_fn_arith


# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
  as_status=$1; test $as_status -eq 0 && as_status=1
  if test "$4"; then
    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
  fi
  $as_echo "$as_me: error: $2" >&2
  as_fn_exit $as_status
} # as_fn_error

if expr a : '\(a\)' >/dev/null 2>&1 &&
   test "X`expr 00001 : '.*\(...\)'`" = X001; then
  as_expr=expr
else
  as_expr=false
fi

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

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

if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
  as_dirname=dirname
else
  as_dirname=false
fi

# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits


  as_lineno_1=$LINENO as_lineno_1a=$LINENO
  as_lineno_2=$LINENO as_lineno_2a=$LINENO
  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
  sed -n '
    p
    /[$]LINENO/=
  ' <$as_myself |
    sed '
      s/[$]LINENO.*/&-/
      t lineno
      b
      :lineno
      N
      :loop
      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
      t loop
      s/-\n.*//
    ' >$as_me.lineno &&
  chmod +x "$as_me.lineno" ||
    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }

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

ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
  case `echo 'xy\c'` in
  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
  xy)  ECHO_C='\c';;
  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
       ECHO_T='	';;
  esac;;
*)
  ECHO_N='-n';;
esac

rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
  rm -f conf$$.dir/conf$$.file
else
  rm -f conf$$.dir
  mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
  if ln -s conf$$.file conf$$ 2>/dev/null; then
    as_ln_s='ln -s'
    # ... but there are two gotchas:
    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
    # In both cases, we have to default to `cp -p'.
    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
      as_ln_s='cp -p'
  elif ln conf$$.file conf$$ 2>/dev/null; then
    as_ln_s=ln
  else
    as_ln_s='cp -p'
  fi
else
  as_ln_s='cp -p'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null

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

if test -x / >/dev/null 2>&1; then
  as_test_x='test -x'
else
  if ls -dL / >/dev/null 2>&1; then
    as_ls_L_option=L
  else
    as_ls_L_option=
  fi
  as_test_x='
    eval sh -c '\''
      if test -d "$1"; then
	test -d "$1/.";
      else
	case $1 in #(
	-*)set "./$1";;
	esac;
	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
	???[sx]*):;;*)false;;esac;fi
    '\'' sh
  '
fi
as_executable_p=$as_test_x

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

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





SHELL=${CONFIG_SHELL-/bin/sh}

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


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

# CLI Arguments to pass to the debugging scripts.
at_debug_args=
# -e sets to true
at_errexit_p=false
# Shall we be verbose?  ':' means no, empty means yes.
at_verbose=:
at_quiet=
# Running several jobs in parallel, 0 means as many as test groups.
at_jobs=1
at_traceon=:
at_trace_echo=:
at_check_filter_trace=:

# Shall we keep the debug scripts?  Must be `:' when the suite is
# run by a debug script, so that the script doesn't remove itself.
at_debug_p=false
# Display help message?
at_help_p=false
# Display the version message?
at_version_p=false
# List test groups?
at_list_p=false
# --clean
at_clean=false
# Test groups to run
at_groups=
# Whether to rerun failed tests.
at_recheck=
# Whether a write failure occurred
at_write_fail=0

# The directory we run the suite in.  Default to . if no -C option.
at_dir=`pwd`
# An absolute reference to this testsuite script.
case $as_myself in
  [\\/]* | ?:[\\/]* ) at_myself=$as_myself ;;
  * ) at_myself=$at_dir/$as_myself ;;
esac
# Whether -C is in effect.
at_change_dir=false

# Whether to enable colored test results.
at_color=auto
# List of the tested programs.
at_tested='test_mat'
# As many question marks as there are digits in the last test group number.
# Used to normalize the test group numbers so that `ls' lists them in
# numerical order.
at_format='???'
# Description of all the test groups.
at_help_all="1;mat4_read.at:29;Read 2d double-precision array;mat4_read_le;
2;mat4_read.at:47;Read 2d double-precision complex array;mat4_read_le;
3;mat4_read.at:65;Read 2D character array;mat4_read_le;
4;mat4_read_be.at:29;Read 2d double-precision array;mat4_read_be;
5;mat4_read_be.at:47;Read 2d double-precision complex array;mat4_read_be;
6;mat4_read_be.at:65;Read 2D character array;mat4_read_be;
7;mat5_uncompressed_read_le.at:27;Read 2D double-precision array;;
8;mat5_uncompressed_read_le.at:44;Read 2D single-precision array;;
9;mat5_uncompressed_read_le.at:61;Read 2D 64-bit integer array;;
10;mat5_uncompressed_read_le.at:78;Read 2D 64-bit unsigned integer array;;
11;mat5_uncompressed_read_le.at:95;Read 2D 32-bit integer array;;
12;mat5_uncompressed_read_le.at:112;Read 2D 32-bit unsigned integer array;;
13;mat5_uncompressed_read_le.at:129;Read 2D 16-bit integer array;;
14;mat5_uncompressed_read_le.at:146;Read 2D 16-bit unsigned integer array;;
15;mat5_uncompressed_read_le.at:163;Read 2D 8-bit integer array;;
16;mat5_uncompressed_read_le.at:180;Read 2D 8-bit unsigned integer array;;
17;mat5_uncompressed_read_le.at:197;Read 2D double-precision complex array;;
18;mat5_uncompressed_read_le.at:214;Read 2D single-precision complex array;;
19;mat5_uncompressed_read_le.at:231;Read 2D 64-bit integer complex array;;
20;mat5_uncompressed_read_le.at:248;Read 2D 64-bit unsigned integer complex array;;
21;mat5_uncompressed_read_le.at:265;Read 2D 32-bit integer complex array;;
22;mat5_uncompressed_read_le.at:282;Read 2D 32-bit unsigned integer complex array;;
23;mat5_uncompressed_read_le.at:299;Read 2D 16-bit integer complex array;;
24;mat5_uncompressed_read_le.at:316;Read 2D 16-bit unsigned integer complex array;;
25;mat5_uncompressed_read_le.at:333;Read 2D 8-bit integer complex array;;
26;mat5_uncompressed_read_le.at:350;Read 2D 8-bit unsigned integer complex array;;
27;mat5_uncompressed_read_le.at:367;Read double-precision sparse array;;
28;mat5_uncompressed_read_le.at:385;Read double-precision sparse complex array;;
29;mat5_uncompressed_read_le.at:403;Read empty array;;
30;mat5_uncompressed_read_le.at:413;Read 2D character array;;
31;mat5_uncompressed_read_le.at:430;Read empty structure array;;
32;mat5_uncompressed_read_le.at:443;Read empty structure array with fields;;
33;mat5_uncompressed_read_le.at:460;Read structure array with empty fields;;
34;mat5_uncompressed_read_le.at:495;Read structure array with double-precision fields;;
35;mat5_uncompressed_read_le.at:544;Read structure array with single-precision fields;;
36;mat5_uncompressed_read_le.at:593;Read structure array with 64-bit integer fields;;
37;mat5_uncompressed_read_le.at:642;Read structure array with 64-bit unsigned integer fields;;
38;mat5_uncompressed_read_le.at:691;Read structure array with 32-bit integer fields;;
39;mat5_uncompressed_read_le.at:740;Read structure array with 32-bit unsigned integer fields;;
40;mat5_uncompressed_read_le.at:789;Read structure array with 16-bit integer fields;;
41;mat5_uncompressed_read_le.at:838;Read structure array with 16-bit unsigned integer fields;;
42;mat5_uncompressed_read_le.at:887;Read structure array with 8-bit integer fields;;
43;mat5_uncompressed_read_le.at:936;Read structure array with 8-bit unsigned integer fields;;
44;mat5_uncompressed_read_le.at:985;Read structure array with complex double-precision fields;;
45;mat5_uncompressed_read_le.at:1034;Read structure array with complex single-precision fields;;
46;mat5_uncompressed_read_le.at:1083;Read structure array with complex 64-bit integer fields;;
47;mat5_uncompressed_read_le.at:1132;Read structure array with complex 64-bit unsigned integer fields;;
48;mat5_uncompressed_read_le.at:1181;Read structure array with complex 32-bit integer fields;;
49;mat5_uncompressed_read_le.at:1230;Read structure array with complex 32-bit unsigned integer fields;;
50;mat5_uncompressed_read_le.at:1279;Read structure array with complex 16-bit integer fields;;
51;mat5_uncompressed_read_le.at:1328;Read structure array with complex 16-bit unsigned integer fields;;
52;mat5_uncompressed_read_le.at:1377;Read structure array with complex 8-bit integer fields;;
53;mat5_uncompressed_read_le.at:1426;Read structure array with complex 8-bit unsigned integer fields;;
54;mat5_uncompressed_read_le.at:1475;Read structure array with double-precision sparse fields;;
55;mat5_uncompressed_read_le.at:1530;Read structure array with complex double-precision sparse fields;;
56;mat5_uncompressed_read_le.at:1585;Read structure array with character fields;;
57;mat5_uncompressed_read_le.at:1630;Read empty cell array;;
58;mat5_uncompressed_read_le.at:1643;Read cell array with empty arrays;;
59;mat5_uncompressed_read_le.at:1686;Read cell array with double-precision arrays;;
60;mat5_uncompressed_read_le.at:1750;Read cell array with single-precision arrays;;
61;mat5_uncompressed_read_le.at:1814;Read cell array with 64-bit integer arrays;;
62;mat5_uncompressed_read_le.at:1878;Read cell array with 64-bit unsigned integer arrays;;
63;mat5_uncompressed_read_le.at:1942;Read cell array with 32-bit integer arrays;;
64;mat5_uncompressed_read_le.at:2006;Read cell array with 32-bit unsigned integer arrays;;
65;mat5_uncompressed_read_le.at:2070;Read cell array with 16-bit integer arrays;;
66;mat5_uncompressed_read_le.at:2134;Read cell array with 16-bit unsigned integer arrays;;
67;mat5_uncompressed_read_le.at:2198;Read cell array with 8-bit integer arrays;;
68;mat5_uncompressed_read_le.at:2262;Read cell array with 8-bit unsigned integer arrays;;
69;mat5_uncompressed_read_le.at:2326;Read cell array with double-precision sparse arrays;;
70;mat5_uncompressed_read_le.at:2379;Read cell array with complex double-precision sparse arrays;;
71;mat5_uncompressed_read_le.at:2432;Read cell array with character arrays;;
72;mat5_uncompressed_read_le.at:2473;Read cell array with empty structure arrays;;
73;mat5_uncompressed_read_le.at:2530;Read cell array with structure arrays (numeric fields);;
74;mat5_uncompressed_read_le.at:3383;Read cell array with structure arrays (sparse fields);;
75;mat5_uncompressed_read_le.at:3492;Read cell array structure arrays (character fields);;
76;mat5_compressed_read_le.at:27;Read 2D double-precision array;;
77;mat5_compressed_read_le.at:45;Read 2D single-precision array;;
78;mat5_compressed_read_le.at:63;Read 2D 64-bit integer array;;
79;mat5_compressed_read_le.at:81;Read 2D 64-bit unsigned integer array;;
80;mat5_compressed_read_le.at:99;Read 2D 32-bit integer array;;
81;mat5_compressed_read_le.at:117;Read 2D 32-bit unsigned integer array;;
82;mat5_compressed_read_le.at:135;Read 2D 16-bit integer array;;
83;mat5_compressed_read_le.at:153;Read 2D 16-bit unsigned integer array;;
84;mat5_compressed_read_le.at:171;Read 2D 8-bit integer array;;
85;mat5_compressed_read_le.at:189;Read 2D 8-bit unsigned integer array;;
86;mat5_compressed_read_le.at:207;Read 2D double-precision complex array;;
87;mat5_compressed_read_le.at:225;Read 2D single-precision complex array;;
88;mat5_compressed_read_le.at:243;Read 2D 64-bit integer complex array;;
89;mat5_compressed_read_le.at:261;Read 2D 64-bit unsigned integer complex array;;
90;mat5_compressed_read_le.at:279;Read 2D 32-bit integer complex array;;
91;mat5_compressed_read_le.at:297;Read 2D 32-bit unsigned integer complex array;;
92;mat5_compressed_read_le.at:315;Read 2D 16-bit integer complex array;;
93;mat5_compressed_read_le.at:333;Read 2D 16-bit unsigned integer complex array;;
94;mat5_compressed_read_le.at:351;Read 2D 8-bit integer complex array;;
95;mat5_compressed_read_le.at:369;Read 2D 8-bit unsigned integer complex array;;
96;mat5_compressed_read_le.at:387;Read double-precision sparse array;;
97;mat5_compressed_read_le.at:406;Read double-precision sparse complex array;;
98;mat5_compressed_read_le.at:425;Read empty array;;
99;mat5_compressed_read_le.at:436;Read 2D character array;;
100;mat5_compressed_read_le.at:454;Read empty structure array;;
101;mat5_compressed_read_le.at:468;Read empty structure array with fields;;
102;mat5_compressed_read_le.at:486;Read structure array with empty fields;;
103;mat5_compressed_read_le.at:522;Read structure array with double-precision fields;;
104;mat5_compressed_read_le.at:572;Read structure array with single-precision fields;;
105;mat5_compressed_read_le.at:622;Read structure array with 64-bit integer fields;;
106;mat5_compressed_read_le.at:672;Read structure array with 64-bit unsigned integer fields;;
107;mat5_compressed_read_le.at:722;Read structure array with 32-bit integer fields;;
108;mat5_compressed_read_le.at:772;Read structure array with 32-bit unsigned integer fields;;
109;mat5_compressed_read_le.at:822;Read structure array with 16-bit integer fields;;
110;mat5_compressed_read_le.at:872;Read structure array with 16-bit unsigned integer fields;;
111;mat5_compressed_read_le.at:922;Read structure array with 8-bit integer fields;;
112;mat5_compressed_read_le.at:972;Read structure array with 8-bit unsigned integer fields;;
113;mat5_compressed_read_le.at:1022;Read structure array with complex double-precision fields;;
114;mat5_compressed_read_le.at:1072;Read structure array with complex single-precision fields;;
115;mat5_compressed_read_le.at:1122;Read structure array with complex 64-bit integer fields;;
116;mat5_compressed_read_le.at:1172;Read structure array with complex 64-bit unsigned integer fields;;
117;mat5_compressed_read_le.at:1222;Read structure array with complex 32-bit integer fields;;
118;mat5_compressed_read_le.at:1272;Read structure array with complex 32-bit unsigned integer fields;;
119;mat5_compressed_read_le.at:1322;Read structure array with complex 16-bit integer fields;;
120;mat5_compressed_read_le.at:1372;Read structure array with complex 16-bit unsigned integer fields;;
121;mat5_compressed_read_le.at:1422;Read structure array with complex 8-bit integer fields;;
122;mat5_compressed_read_le.at:1472;Read structure array with complex 8-bit unsigned integer fields;;
123;mat5_compressed_read_le.at:1522;Read structure array with double-precision sparse fields;;
124;mat5_compressed_read_le.at:1578;Read structure array with complex double-precision sparse fields;;
125;mat5_compressed_read_le.at:1634;Read structure array with character fields;;
126;mat5_compressed_read_le.at:1680;Read empty cell array;;
127;mat5_compressed_read_le.at:1694;Read cell array with empty arrays;;
128;mat5_compressed_read_le.at:1738;Read cell array with double-precision arrays;;
129;mat5_compressed_read_le.at:1803;Read cell array with single-precision arrays;;
130;mat5_compressed_read_le.at:1868;Read cell array with 64-bit integer arrays;;
131;mat5_compressed_read_le.at:1933;Read cell array with 64-bit unsigned integer arrays;;
132;mat5_compressed_read_le.at:1998;Read cell array with 32-bit integer arrays;;
133;mat5_compressed_read_le.at:2063;Read cell array with 32-bit unsigned integer arrays;;
134;mat5_compressed_read_le.at:2128;Read cell array with 16-bit integer arrays;;
135;mat5_compressed_read_le.at:2193;Read cell array with 16-bit unsigned integer arrays;;
136;mat5_compressed_read_le.at:2258;Read cell array with 8-bit integer arrays;;
137;mat5_compressed_read_le.at:2323;Read cell array with 8-bit unsigned integer arrays;;
138;mat5_compressed_read_le.at:2388;Read cell array with double-precision sparse arrays;;
139;mat5_compressed_read_le.at:2442;Read cell array with complex double-precision sparse arrays;;
140;mat5_compressed_read_le.at:2496;Read cell array with character arrays;;
141;mat5_compressed_read_le.at:2538;Read cell array with empty structure arrays;;
142;mat5_compressed_read_le.at:2596;Read cell array with structure arrays (numeric fields);;
143;mat5_compressed_read_le.at:3450;Read cell array with structure arrays (sparse fields);;
144;mat5_compressed_read_le.at:3560;Read cell array structure arrays (character fields);;
145;mat5_uncompressed_read_be.at:27;Read 2D double-precision array;;
146;mat5_uncompressed_read_be.at:44;Read 2D single-precision array;;
147;mat5_uncompressed_read_be.at:61;Read 2D 64-bit integer array;;
148;mat5_uncompressed_read_be.at:78;Read 2D 64-bit unsigned integer array;;
149;mat5_uncompressed_read_be.at:95;Read 2D 32-bit integer array;;
150;mat5_uncompressed_read_be.at:112;Read 2D 32-bit unsigned integer array;;
151;mat5_uncompressed_read_be.at:129;Read 2D 16-bit integer array;;
152;mat5_uncompressed_read_be.at:146;Read 2D 16-bit unsigned integer array;;
153;mat5_uncompressed_read_be.at:163;Read 2D 8-bit integer array;;
154;mat5_uncompressed_read_be.at:180;Read 2D 8-bit unsigned integer array;;
155;mat5_uncompressed_read_be.at:197;Read 2D double-precision complex array;;
156;mat5_uncompressed_read_be.at:214;Read 2D single-precision complex array;;
157;mat5_uncompressed_read_be.at:231;Read 2D 64-bit integer complex array;;
158;mat5_uncompressed_read_be.at:248;Read 2D 64-bit unsigned integer complex array;;
159;mat5_uncompressed_read_be.at:265;Read 2D 32-bit integer complex array;;
160;mat5_uncompressed_read_be.at:282;Read 2D 32-bit unsigned integer complex array;;
161;mat5_uncompressed_read_be.at:299;Read 2D 16-bit integer complex array;;
162;mat5_uncompressed_read_be.at:316;Read 2D 16-bit unsigned integer complex array;;
163;mat5_uncompressed_read_be.at:333;Read 2D 8-bit integer complex array;;
164;mat5_uncompressed_read_be.at:350;Read 2D 8-bit unsigned integer complex array;;
165;mat5_uncompressed_read_be.at:367;Read double-precision sparse array;;
166;mat5_uncompressed_read_be.at:385;Read double-precision sparse complex array;;
167;mat5_uncompressed_read_be.at:403;Read empty array;;
168;mat5_uncompressed_read_be.at:413;Read 2D character array;;
169;mat5_uncompressed_read_be.at:430;Read empty structure array;;
170;mat5_uncompressed_read_be.at:442;Read empty structure array with fields;;
171;mat5_uncompressed_read_be.at:458;Read structure array with empty fields;;
172;mat5_uncompressed_read_be.at:492;Read structure array with double-precision fields;;
173;mat5_uncompressed_read_be.at:540;Read structure array with single-precision fields;;
174;mat5_uncompressed_read_be.at:588;Read structure array with 64-bit integer fields;;
175;mat5_uncompressed_read_be.at:636;Read structure array with 64-bit unsigned integer fields;;
176;mat5_uncompressed_read_be.at:684;Read structure array with 32-bit integer fields;;
177;mat5_uncompressed_read_be.at:732;Read structure array with 32-bit unsigned integer fields;;
178;mat5_uncompressed_read_be.at:780;Read structure array with 16-bit integer fields;;
179;mat5_uncompressed_read_be.at:828;Read structure array with 16-bit unsigned integer fields;;
180;mat5_uncompressed_read_be.at:876;Read structure array with 8-bit integer fields;;
181;mat5_uncompressed_read_be.at:924;Read structure array with 8-bit unsigned integer fields;;
182;mat5_uncompressed_read_be.at:972;Read structure array with complex double-precision fields;;
183;mat5_uncompressed_read_be.at:1020;Read structure array with complex single-precision fields;;
184;mat5_uncompressed_read_be.at:1068;Read structure array with complex 64-bit integer fields;;
185;mat5_uncompressed_read_be.at:1116;Read structure array with complex 64-bit unsigned integer fields;;
186;mat5_uncompressed_read_be.at:1164;Read structure array with complex 32-bit integer fields;;
187;mat5_uncompressed_read_be.at:1212;Read structure array with complex 32-bit unsigned integer fields;;
188;mat5_uncompressed_read_be.at:1260;Read structure array with complex 16-bit integer fields;;
189;mat5_uncompressed_read_be.at:1308;Read structure array with complex 16-bit unsigned integer fields;;
190;mat5_uncompressed_read_be.at:1356;Read structure array with complex 8-bit integer fields;;
191;mat5_uncompressed_read_be.at:1404;Read structure array with complex 8-bit unsigned integer fields;;
192;mat5_uncompressed_read_be.at:1453;Read structure array with double-precision sparse fields;;
193;mat5_uncompressed_read_be.at:1508;Read structure array with complex double-precision sparse fields;;
194;mat5_uncompressed_read_be.at:1563;Read structure array with character fields;;
195;mat5_uncompressed_read_be.at:1608;Read empty cell array;;
196;mat5_uncompressed_read_be.at:1621;Read cell array with empty arrays;;
197;mat5_uncompressed_read_be.at:1664;Read cell array with double-precision arrays;;
198;mat5_uncompressed_read_be.at:1728;Read cell array with single-precision arrays;;
199;mat5_uncompressed_read_be.at:1792;Read cell array with 64-bit integer arrays;;
200;mat5_uncompressed_read_be.at:1856;Read cell array with 64-bit unsigned integer arrays;;
201;mat5_uncompressed_read_be.at:1920;Read cell array with 32-bit integer arrays;;
202;mat5_uncompressed_read_be.at:1984;Read cell array with 32-bit unsigned integer arrays;;
203;mat5_uncompressed_read_be.at:2048;Read cell array with 16-bit integer arrays;;
204;mat5_uncompressed_read_be.at:2112;Read cell array with 16-bit unsigned integer arrays;;
205;mat5_uncompressed_read_be.at:2176;Read cell array with 8-bit integer arrays;;
206;mat5_uncompressed_read_be.at:2240;Read cell array with 8-bit unsigned integer arrays;;
207;mat5_uncompressed_read_be.at:2304;Read cell array with double-precision sparse arrays;;
208;mat5_uncompressed_read_be.at:2357;Read cell array with complex double-precision sparse arrays;;
209;mat5_uncompressed_read_be.at:2410;Read cell array with character arrays;;
210;mat5_uncompressed_read_be.at:2451;Read cell array with empty structure arrays;;
211;mat5_uncompressed_read_be.at:2508;Read cell array with structure arrays (numeric fields);;
212;mat5_uncompressed_read_be.at:3361;Read cell array with structure arrays (sparse fields);;
213;mat5_uncompressed_read_be.at:3470;Read cell array structure arrays (character fields);;
214;mat5_compressed_read_be.at:27;Read 2D double-precision array;;
215;mat5_compressed_read_be.at:45;Read 2D single-precision array;;
216;mat5_compressed_read_be.at:63;Read 2D 64-bit integer array;;
217;mat5_compressed_read_be.at:81;Read 2D 64-bit unsigned integer array;;
218;mat5_compressed_read_be.at:99;Read 2D 32-bit integer array;;
219;mat5_compressed_read_be.at:117;Read 2D 32-bit unsigned integer array;;
220;mat5_compressed_read_be.at:135;Read 2D 16-bit integer array;;
221;mat5_compressed_read_be.at:153;Read 2D 16-bit unsigned integer array;;
222;mat5_compressed_read_be.at:171;Read 2D 8-bit integer array;;
223;mat5_compressed_read_be.at:189;Read 2D 8-bit unsigned integer array;;
224;mat5_compressed_read_be.at:207;Read 2D double-precision complex array;;
225;mat5_compressed_read_be.at:225;Read 2D single-precision complex array;;
226;mat5_compressed_read_be.at:243;Read 2D 64-bit integer complex array;;
227;mat5_compressed_read_be.at:261;Read 2D 64-bit unsigned integer complex array;;
228;mat5_compressed_read_be.at:279;Read 2D 32-bit integer complex array;;
229;mat5_compressed_read_be.at:297;Read 2D 32-bit unsigned integer complex array;;
230;mat5_compressed_read_be.at:315;Read 2D 16-bit integer complex array;;
231;mat5_compressed_read_be.at:333;Read 2D 16-bit unsigned integer complex array;;
232;mat5_compressed_read_be.at:351;Read 2D 8-bit integer complex array;;
233;mat5_compressed_read_be.at:369;Read 2D 8-bit unsigned integer complex array;;
234;mat5_compressed_read_be.at:387;Read double-precision sparse array;;
235;mat5_compressed_read_be.at:406;Read double-precision sparse complex array;;
236;mat5_compressed_read_be.at:425;Read empty array;;
237;mat5_compressed_read_be.at:436;Read 2D character array;;
238;mat5_compressed_read_be.at:454;Read empty structure array;;
239;mat5_compressed_read_be.at:467;Read empty structure array with fields;;
240;mat5_compressed_read_be.at:484;Read structure array with empty fields;;
241;mat5_compressed_read_be.at:519;Read structure array with double-precision fields;;
242;mat5_compressed_read_be.at:568;Read structure array with single-precision fields;;
243;mat5_compressed_read_be.at:617;Read structure array with 64-bit integer fields;;
244;mat5_compressed_read_be.at:666;Read structure array with 64-bit unsigned integer fields;;
245;mat5_compressed_read_be.at:715;Read structure array with 32-bit integer fields;;
246;mat5_compressed_read_be.at:764;Read structure array with 32-bit unsigned integer fields;;
247;mat5_compressed_read_be.at:813;Read structure array with 16-bit integer fields;;
248;mat5_compressed_read_be.at:862;Read structure array with 16-bit unsigned integer fields;;
249;mat5_compressed_read_be.at:911;Read structure array with 8-bit integer fields;;
250;mat5_compressed_read_be.at:960;Read structure array with 8-bit unsigned integer fields;;
251;mat5_compressed_read_be.at:1009;Read structure array with complex double-precision fields;;
252;mat5_compressed_read_be.at:1058;Read structure array with complex single-precision fields;;
253;mat5_compressed_read_be.at:1107;Read structure array with complex 64-bit integer fields;;
254;mat5_compressed_read_be.at:1156;Read structure array with complex 64-bit unsigned integer fields;;
255;mat5_compressed_read_be.at:1205;Read structure array with complex 32-bit integer fields;;
256;mat5_compressed_read_be.at:1254;Read structure array with complex 32-bit unsigned integer fields;;
257;mat5_compressed_read_be.at:1303;Read structure array with complex 16-bit integer fields;;
258;mat5_compressed_read_be.at:1352;Read structure array with complex 16-bit unsigned integer fields;;
259;mat5_compressed_read_be.at:1401;Read structure array with complex 8-bit integer fields;;
260;mat5_compressed_read_be.at:1450;Read structure array with complex 8-bit unsigned integer fields;;
261;mat5_compressed_read_be.at:1500;Read structure array with double-precision sparse fields;;
262;mat5_compressed_read_be.at:1556;Read structure array with complex double-precision sparse fields;;
263;mat5_compressed_read_be.at:1612;Read structure array with character fields;;
264;mat5_compressed_read_be.at:1658;Read empty cell array;;
265;mat5_compressed_read_be.at:1672;Read cell array with empty arrays;;
266;mat5_compressed_read_be.at:1716;Read cell array with double-precision arrays;;
267;mat5_compressed_read_be.at:1781;Read cell array with single-precision arrays;;
268;mat5_compressed_read_be.at:1846;Read cell array with 64-bit integer arrays;;
269;mat5_compressed_read_be.at:1911;Read cell array with 64-bit unsigned integer arrays;;
270;mat5_compressed_read_be.at:1976;Read cell array with 32-bit integer arrays;;
271;mat5_compressed_read_be.at:2041;Read cell array with 32-bit unsigned integer arrays;;
272;mat5_compressed_read_be.at:2106;Read cell array with 16-bit integer arrays;;
273;mat5_compressed_read_be.at:2171;Read cell array with 16-bit unsigned integer arrays;;
274;mat5_compressed_read_be.at:2236;Read cell array with 8-bit integer arrays;;
275;mat5_compressed_read_be.at:2301;Read cell array with 8-bit unsigned integer arrays;;
276;mat5_compressed_read_be.at:2366;Read cell array with double-precision sparse arrays;;
277;mat5_compressed_read_be.at:2420;Read cell array with complex double-precision sparse arrays;;
278;mat5_compressed_read_be.at:2474;Read cell array with character arrays;;
279;mat5_compressed_read_be.at:2516;Read cell array with empty structure arrays;;
280;mat5_compressed_read_be.at:2574;Read cell array with structure arrays (numeric fields);;
281;mat5_compressed_read_be.at:3428;Read cell array with structure arrays (sparse fields);;
282;mat5_compressed_read_be.at:3538;Read cell array structure arrays (character fields);;
283;mat73_read_le.at:27;Read 2D double-precision array;;
284;mat73_read_le.at:45;Read 2D single-precision array;;
285;mat73_read_le.at:63;Read 2D 64-bit integer array;;
286;mat73_read_le.at:81;Read 2D 64-bit unsigned integer array;;
287;mat73_read_le.at:99;Read 2D 32-bit integer array;;
288;mat73_read_le.at:117;Read 2D 32-bit unsigned integer array;;
289;mat73_read_le.at:135;Read 2D 16-bit integer array;;
290;mat73_read_le.at:153;Read 2D 16-bit unsigned integer array;;
291;mat73_read_le.at:171;Read 2D 8-bit integer array;;
292;mat73_read_le.at:189;Read 2D 8-bit unsigned integer array;;
293;mat73_read_le.at:207;Read 2D double-precision complex array;;
294;mat73_read_le.at:225;Read 2D single-precision complex array;;
295;mat73_read_le.at:243;Read 2D 64-bit integer complex array;;
296;mat73_read_le.at:261;Read 2D 64-bit unsigned integer complex array;;
297;mat73_read_le.at:279;Read 2D 32-bit integer complex array;;
298;mat73_read_le.at:297;Read 2D 32-bit unsigned integer complex array;;
299;mat73_read_le.at:315;Read 2D 16-bit integer complex array;;
300;mat73_read_le.at:333;Read 2D 16-bit unsigned integer complex array;;
301;mat73_read_le.at:351;Read 2D 8-bit integer complex array;;
302;mat73_read_le.at:369;Read 2D 8-bit unsigned integer complex array;;
303;mat73_read_le.at:387;Read double-precision sparse array;;
304;mat73_read_le.at:406;Read double-precision sparse complex array;;
305;mat73_read_le.at:425;Read empty array;;
306;mat73_read_le.at:437;Read 2D character array;;
307;mat73_read_le.at:455;Read empty structure array;;
308;mat73_read_le.at:469;Read empty structure array with fields;;
309;mat73_read_le.at:487;Read structure array with empty fields;;
310;mat73_read_le.at:525;Read structure array with double-precision fields;;
311;mat73_read_le.at:575;Read structure array with single-precision fields;;
312;mat73_read_le.at:625;Read structure array with 64-bit integer fields;;
313;mat73_read_le.at:675;Read structure array with 64-bit unsigned integer fields;;
314;mat73_read_le.at:725;Read structure array with 32-bit integer fields;;
315;mat73_read_le.at:775;Read structure array with 32-bit unsigned integer fields;;
316;mat73_read_le.at:825;Read structure array with 16-bit integer fields;;
317;mat73_read_le.at:875;Read structure array with 16-bit unsigned integer fields;;
318;mat73_read_le.at:925;Read structure array with 8-bit integer fields;;
319;mat73_read_le.at:975;Read structure array with 8-bit unsigned integer fields;;
320;mat73_read_le.at:1025;Read structure array with complex double-precision fields;;
321;mat73_read_le.at:1075;Read structure array with complex single-precision fields;;
322;mat73_read_le.at:1125;Read structure array with complex 64-bit integer fields;;
323;mat73_read_le.at:1175;Read structure array with complex 64-bit unsigned integer fields;;
324;mat73_read_le.at:1225;Read structure array with complex 32-bit integer fields;;
325;mat73_read_le.at:1275;Read structure array with complex 32-bit unsigned integer fields;;
326;mat73_read_le.at:1325;Read structure array with complex 16-bit integer fields;;
327;mat73_read_le.at:1375;Read structure array with complex 16-bit unsigned integer fields;;
328;mat73_read_le.at:1425;Read structure array with complex 8-bit integer fields;;
329;mat73_read_le.at:1475;Read structure array with complex 8-bit unsigned integer fields;;
330;mat73_read_le.at:1525;Read structure array with double-precision sparse fields;;
331;mat73_read_le.at:1581;Read structure array with complex double-precision sparse fields;;
332;mat73_read_le.at:1637;Read structure array with character fields;;
333;mat73_read_le.at:1683;Read empty cell array;;
334;mat73_read_le.at:1697;Read cell array with empty arrays;;
335;mat73_read_le.at:1751;Read cell array with double-precision arrays;;
336;mat73_read_le.at:1816;Read cell array with single-precision arrays;;
337;mat73_read_le.at:1881;Read cell array with 64-bit integer arrays;;
338;mat73_read_le.at:1946;Read cell array with 64-bit unsigned integer arrays;;
339;mat73_read_le.at:2011;Read cell array with 32-bit integer arrays;;
340;mat73_read_le.at:2076;Read cell array with 32-bit unsigned integer arrays;;
341;mat73_read_le.at:2141;Read cell array with 16-bit integer arrays;;
342;mat73_read_le.at:2206;Read cell array with 16-bit unsigned integer arrays;;
343;mat73_read_le.at:2271;Read cell array with 8-bit integer arrays;;
344;mat73_read_le.at:2336;Read cell array with 8-bit unsigned integer arrays;;
345;mat73_read_le.at:2401;Read cell array with double-precision sparse arrays;;
346;mat73_read_le.at:2455;Read cell array with complex double-precision sparse arrays;;
347;mat73_read_le.at:2509;Read cell array with character arrays;;
348;mat73_read_le.at:2551;Read cell array with empty structure arrays;;
349;mat73_read_le.at:2611;Read cell array with structure arrays (numeric fields);;
350;mat73_read_le.at:3465;Read cell array with structure arrays (sparse fields);;
351;mat73_read_le.at:3575;Read cell array structure arrays (character fields);;
352;mat73_read_be.at:27;Read 2D double-precision array;;
353;mat73_read_be.at:45;Read 2D single-precision array;;
354;mat73_read_be.at:63;Read 2D 64-bit integer array;;
355;mat73_read_be.at:81;Read 2D 64-bit unsigned integer array;;
356;mat73_read_be.at:99;Read 2D 32-bit integer array;;
357;mat73_read_be.at:117;Read 2D 32-bit unsigned integer array;;
358;mat73_read_be.at:135;Read 2D 16-bit integer array;;
359;mat73_read_be.at:153;Read 2D 16-bit unsigned integer array;;
360;mat73_read_be.at:171;Read 2D 8-bit integer array;;
361;mat73_read_be.at:189;Read 2D 8-bit unsigned integer array;;
362;mat73_read_be.at:207;Read 2D double-precision complex array;;
363;mat73_read_be.at:225;Read 2D single-precision complex array;;
364;mat73_read_be.at:243;Read 2D 64-bit integer complex array;;
365;mat73_read_be.at:261;Read 2D 64-bit unsigned integer complex array;;
366;mat73_read_be.at:279;Read 2D 32-bit integer complex array;;
367;mat73_read_be.at:297;Read 2D 32-bit unsigned integer complex array;;
368;mat73_read_be.at:315;Read 2D 16-bit integer complex array;;
369;mat73_read_be.at:333;Read 2D 16-bit unsigned integer complex array;;
370;mat73_read_be.at:351;Read 2D 8-bit integer complex array;;
371;mat73_read_be.at:369;Read 2D 8-bit unsigned integer complex array;;
372;mat73_read_be.at:387;Read double-precision sparse array;;
373;mat73_read_be.at:406;Read double-precision sparse complex array;;
374;mat73_read_be.at:425;Read empty array;;
375;mat73_read_be.at:437;Read 2D character array;;
376;mat73_read_be.at:455;Read empty structure array;;
377;mat73_read_be.at:468;Read empty structure array with fields;;
378;mat73_read_be.at:485;Read structure array with empty fields;;
379;mat73_read_be.at:522;Read structure array with double-precision fields;;
380;mat73_read_be.at:571;Read structure array with single-precision fields;;
381;mat73_read_be.at:620;Read structure array with 64-bit integer fields;;
382;mat73_read_be.at:669;Read structure array with 64-bit unsigned integer fields;;
383;mat73_read_be.at:718;Read structure array with 32-bit integer fields;;
384;mat73_read_be.at:767;Read structure array with 32-bit unsigned integer fields;;
385;mat73_read_be.at:816;Read structure array with 16-bit integer fields;;
386;mat73_read_be.at:865;Read structure array with 16-bit unsigned integer fields;;
387;mat73_read_be.at:914;Read structure array with 8-bit integer fields;;
388;mat73_read_be.at:963;Read structure array with 8-bit unsigned integer fields;;
389;mat73_read_be.at:1012;Read structure array with complex double-precision fields;;
390;mat73_read_be.at:1061;Read structure array with complex single-precision fields;;
391;mat73_read_be.at:1110;Read structure array with complex 64-bit integer fields;;
392;mat73_read_be.at:1159;Read structure array with complex 64-bit unsigned integer fields;;
393;mat73_read_be.at:1208;Read structure array with complex 32-bit integer fields;;
394;mat73_read_be.at:1257;Read structure array with complex 32-bit unsigned integer fields;;
395;mat73_read_be.at:1306;Read structure array with complex 16-bit integer fields;;
396;mat73_read_be.at:1355;Read structure array with complex 16-bit unsigned integer fields;;
397;mat73_read_be.at:1404;Read structure array with complex 8-bit integer fields;;
398;mat73_read_be.at:1453;Read structure array with complex 8-bit unsigned integer fields;;
399;mat73_read_be.at:1503;Read structure array with double-precision sparse fields;;
400;mat73_read_be.at:1559;Read structure array with complex double-precision sparse fields;;
401;mat73_read_be.at:1615;Read structure array with character fields;;
402;mat73_read_be.at:1661;Read cell array with empty arrays;;
403;mat73_read_be.at:1715;Read cell array with double-precision arrays;;
404;mat73_read_be.at:1780;Read cell array with single-precision arrays;;
405;mat73_read_be.at:1845;Read cell array with 64-bit integer arrays;;
406;mat73_read_be.at:1910;Read cell array with 64-bit unsigned integer arrays;;
407;mat73_read_be.at:1975;Read cell array with 32-bit integer arrays;;
408;mat73_read_be.at:2040;Read cell array with 32-bit unsigned integer arrays;;
409;mat73_read_be.at:2105;Read cell array with 16-bit integer arrays;;
410;mat73_read_be.at:2170;Read cell array with 16-bit unsigned integer arrays;;
411;mat73_read_be.at:2235;Read cell array with 8-bit integer arrays;;
412;mat73_read_be.at:2300;Read cell array with 8-bit unsigned integer arrays;;
413;mat73_read_be.at:2365;Read cell array with double-precision sparse arrays;;
414;mat73_read_be.at:2419;Read cell array with complex double-precision sparse arrays;;
415;mat73_read_be.at:2473;Read cell array with character arrays;;
416;mat73_read_be.at:2515;Read cell array with empty structure arrays;;
417;mat73_read_be.at:2575;Read cell array with structure arrays (numeric fields);;
418;mat73_read_be.at:3429;Read cell array with structure arrays (sparse fields);;
419;mat73_read_be.at:3539;Read cell array structure arrays (character fields);;
420;mat5_uncompressed_write.at:27;Write 2D double-precision array;;
421;mat5_uncompressed_write.at:69;Write 2D single-precision array;;
422;mat5_uncompressed_write.at:111;Write 2D 64-bit integer array;;
423;mat5_uncompressed_write.at:154;Write 2D 64-bit unsigned integer array;;
424;mat5_uncompressed_write.at:197;Write 2D 32-bit integer array;;
425;mat5_uncompressed_write.at:239;Write 2D 32-bit unsigned integer array;;
426;mat5_uncompressed_write.at:281;Write 2D 16-bit integer array;;
427;mat5_uncompressed_write.at:323;Write 2D 16-bit unsigned integer array;;
428;mat5_uncompressed_write.at:365;Write 2D 8-bit integer array;;
429;mat5_uncompressed_write.at:407;Write 2D 8-bit unsigned integer array;;
430;mat5_uncompressed_write.at:449;Write 2D double-precision complex array;;
431;mat5_uncompressed_write.at:491;Write 2D single-precision complex array;;
432;mat5_uncompressed_write.at:533;Write 2D 64-bit integer complex array;;
433;mat5_uncompressed_write.at:576;Write 2D 64-bit unsigned integer complex array;;
434;mat5_uncompressed_write.at:619;Write 2D 32-bit integer complex array;;
435;mat5_uncompressed_write.at:661;Write 2D 32-bit unsigned integer complex array;;
436;mat5_uncompressed_write.at:703;Write 2D 16-bit integer complex array;;
437;mat5_uncompressed_write.at:745;Write 2D 16-bit unsigned integer complex array;;
438;mat5_uncompressed_write.at:787;Write 2D 8-bit integer complex array;;
439;mat5_uncompressed_write.at:829;Write 2D 8-bit unsigned integer complex array;;
440;mat5_uncompressed_write.at:871;Write 2D sparse double-precision array;;
441;mat5_uncompressed_write.at:937;Write 2D sparse complex double-precision array;;
442;mat5_uncompressed_write.at:1003;Write 2D empty array;;
443;mat5_uncompressed_write.at:1038;Write character array;;
444;mat5_uncompressed_write.at:1079;Write empty structure array;;
445;mat5_uncompressed_write.at:1190;Write structure array with 2D double-precision fields;;
446;mat5_uncompressed_write.at:1272;Write structure array with 2D single-precision fields;;
447;mat5_uncompressed_write.at:1354;Write structure array with 2D 64-bit signed integer fields;;
448;mat5_uncompressed_write.at:1437;Write structure array with 2D 64-bit unsigned integer fields;;
449;mat5_uncompressed_write.at:1520;Write structure array with 2D 32-bit signed integer fields;;
450;mat5_uncompressed_write.at:1602;Write structure array with 2D 32-bit unsigned integer fields;;
451;mat5_uncompressed_write.at:1684;Write structure array with 2D 16-bit signed integer fields;;
452;mat5_uncompressed_write.at:1766;Write structure array with 2D 16-bit unsigned integer fields;;
453;mat5_uncompressed_write.at:1848;Write structure array with 2D 8-bit signed integer fields;;
454;mat5_uncompressed_write.at:1930;Write structure array with 2D 8-bit unsigned integer fields;;
455;mat5_uncompressed_write.at:2012;Write structure array with 2D double-precision complex fields;;
456;mat5_uncompressed_write.at:2094;Write structure array with 2D single-precision complex fields;;
457;mat5_uncompressed_write.at:2176;Write structure array with 2D 64-bit signed integer complex fields;;
458;mat5_uncompressed_write.at:2259;Write structure array with 2D 64-bit unsigned integer complex fields;;
459;mat5_uncompressed_write.at:2342;Write structure array with 2D 32-bit signed integer complex fields;;
460;mat5_uncompressed_write.at:2424;Write structure array with 2D 32-bit unsigned integer complex fields;;
461;mat5_uncompressed_write.at:2506;Write structure array with 2D 16-bit signed integer complex fields;;
462;mat5_uncompressed_write.at:2588;Write structure array with 2D 16-bit unsigned integer complex fields;;
463;mat5_uncompressed_write.at:2670;Write structure array with 2D 8-bit signed integer complex fields;;
464;mat5_uncompressed_write.at:2752;Write structure array with 2D 8-bit unsigned integer complex fields;;
465;mat5_uncompressed_write.at:2834;Write empty cell array;;
466;mat5_uncompressed_write.at:2893;Write cell array with 2D double-precision fields;;
467;mat5_uncompressed_write.at:2969;Write cell array with 2D single-precision fields;;
468;mat5_uncompressed_write.at:3045;Write cell array with 2D 64-bit signed integer fields;;
469;mat5_uncompressed_write.at:3122;Write cell array with 2D 64-bit unsigned integer fields;;
470;mat5_uncompressed_write.at:3199;Write cell array with 2D 32-bit signed integer fields;;
471;mat5_uncompressed_write.at:3275;Write cell array with 2D 32-bit unsigned integer fields;;
472;mat5_uncompressed_write.at:3351;Write cell array with 2D 16-bit signed integer fields;;
473;mat5_uncompressed_write.at:3427;Write cell array with 2D 16-bit unsigned integer fields;;
474;mat5_uncompressed_write.at:3503;Write cell array with 2D 8-bit signed integer fields;;
475;mat5_uncompressed_write.at:3579;Write cell array with 2D 8-bit unsigned integer fields;;
476;mat5_uncompressed_write.at:3655;Write cell array with 2D double-precision complex fields;;
477;mat5_uncompressed_write.at:3733;Write cell array with 2D single-precision complex fields;;
478;mat5_uncompressed_write.at:3811;Write cell array with 2D 64-bit signed integer complex fields;;
479;mat5_uncompressed_write.at:3890;Write cell array with 2D 64-bit unsigned integer complex fields;;
480;mat5_uncompressed_write.at:3969;Write cell array with 2D 32-bit signed integer complex fields;;
481;mat5_uncompressed_write.at:4047;Write cell array with 2D 32-bit unsigned integer complex fields;;
482;mat5_uncompressed_write.at:4125;Write cell array with 2D 16-bit signed integer complex fields;;
483;mat5_uncompressed_write.at:4203;Write cell array with 2D 16-bit unsigned integer complex fields;;
484;mat5_uncompressed_write.at:4281;Write cell array with 2D 8-bit signed integer complex fields;;
485;mat5_uncompressed_write.at:4359;Write cell array with 2D 8-bit unsigned integer complex fields;;
486;mat5_compressed_write.at:27;Write 2D double-precision array;;
487;mat5_compressed_write.at:70;Write 2D single-precision array;;
488;mat5_compressed_write.at:113;Write 2D 64-bit integer array;;
489;mat5_compressed_write.at:157;Write 2D 64-bit unsigned integer array;;
490;mat5_compressed_write.at:201;Write 2D 32-bit integer array;;
491;mat5_compressed_write.at:244;Write 2D 32-bit unsigned integer array;;
492;mat5_compressed_write.at:287;Write 2D 16-bit integer array;;
493;mat5_compressed_write.at:330;Write 2D 16-bit unsigned integer array;;
494;mat5_compressed_write.at:373;Write 2D 8-bit integer array;;
495;mat5_compressed_write.at:416;Write 2D 8-bit unsigned integer array;;
496;mat5_compressed_write.at:459;Write 2D double-precision complex array;;
497;mat5_compressed_write.at:502;Write 2D single-precision complex array;;
498;mat5_compressed_write.at:545;Write 2D 64-bit integer complex array;;
499;mat5_compressed_write.at:589;Write 2D 64-bit unsigned integer complex array;;
500;mat5_compressed_write.at:633;Write 2D 32-bit integer complex array;;
501;mat5_compressed_write.at:676;Write 2D 32-bit unsigned integer complex array;;
502;mat5_compressed_write.at:719;Write 2D 16-bit integer complex array;;
503;mat5_compressed_write.at:762;Write 2D 16-bit unsigned integer complex array;;
504;mat5_compressed_write.at:805;Write 2D 8-bit integer complex array;;
505;mat5_compressed_write.at:848;Write 2D 8-bit unsigned integer complex array;;
506;mat5_compressed_write.at:891;Write 2D sparse double-precision array;;
507;mat5_compressed_write.at:958;Write 2D sparse complex double-precision array;;
508;mat5_compressed_write.at:1025;Write 2D empty array;;
509;mat5_compressed_write.at:1061;Write character array;;
510;mat5_compressed_write.at:1103;Write empty structure array;;
511;mat5_compressed_write.at:1215;Write structure array with 2D double-precision fields;;
512;mat5_compressed_write.at:1298;Write structure array with 2D single-precision fields;;
513;mat5_compressed_write.at:1381;Write structure array with 2D 64-bit signed integer fields;;
514;mat5_compressed_write.at:1465;Write structure array with 2D 64-bit unsigned integer fields;;
515;mat5_compressed_write.at:1549;Write structure array with 2D 32-bit signed integer fields;;
516;mat5_compressed_write.at:1632;Write structure array with 2D 32-bit unsigned integer fields;;
517;mat5_compressed_write.at:1715;Write structure array with 2D 16-bit signed integer fields;;
518;mat5_compressed_write.at:1798;Write structure array with 2D 16-bit unsigned integer fields;;
519;mat5_compressed_write.at:1881;Write structure array with 2D 8-bit signed integer fields;;
520;mat5_compressed_write.at:1964;Write structure array with 2D 8-bit unsigned integer fields;;
521;mat5_compressed_write.at:2047;Write structure array with 2D double-precision complex fields;;
522;mat5_compressed_write.at:2130;Write structure array with 2D single-precision complex fields;;
523;mat5_compressed_write.at:2213;Write structure array with 2D 64-bit signed integer complex fields;;
524;mat5_compressed_write.at:2297;Write structure array with 2D 64-bit unsigned integer complex fields;;
525;mat5_compressed_write.at:2381;Write structure array with 2D 32-bit signed integer complex fields;;
526;mat5_compressed_write.at:2464;Write structure array with 2D 32-bit unsigned integer complex fields;;
527;mat5_compressed_write.at:2547;Write structure array with 2D 16-bit signed integer complex fields;;
528;mat5_compressed_write.at:2630;Write structure array with 2D 16-bit unsigned integer complex fields;;
529;mat5_compressed_write.at:2713;Write structure array with 2D 8-bit signed integer complex fields;;
530;mat5_compressed_write.at:2796;Write structure array with 2D 8-bit unsigned integer complex fields;;
531;mat5_compressed_write.at:2879;Write empty cell array;;
532;mat5_compressed_write.at:2933;Write cell array with 2D double-precision fields;;
533;mat5_compressed_write.at:3010;Write cell array with 2D single-precision fields;;
534;mat5_compressed_write.at:3087;Write cell array with 2D 64-bit signed integer fields;;
535;mat5_compressed_write.at:3165;Write cell array with 2D 64-bit unsigned integer fields;;
536;mat5_compressed_write.at:3243;Write cell array with 2D 32-bit signed integer fields;;
537;mat5_compressed_write.at:3320;Write cell array with 2D 32-bit unsigned integer fields;;
538;mat5_compressed_write.at:3397;Write cell array with 2D 16-bit signed integer fields;;
539;mat5_compressed_write.at:3474;Write cell array with 2D 16-bit unsigned integer fields;;
540;mat5_compressed_write.at:3551;Write cell array with 2D 8-bit signed integer fields;;
541;mat5_compressed_write.at:3628;Write cell array with 2D 8-bit unsigned integer fields;;
542;mat5_compressed_write.at:3705;Write cell array with 2D double-precision complex fields;;
543;mat5_compressed_write.at:3784;Write cell array with 2D single-precision complex fields;;
544;mat5_compressed_write.at:3863;Write cell array with 2D 64-bit signed integer complex fields;;
545;mat5_compressed_write.at:3943;Write cell array with 2D 64-bit unsigned integer complex fields;;
546;mat5_compressed_write.at:4023;Write cell array with 2D 32-bit signed integer complex fields;;
547;mat5_compressed_write.at:4102;Write cell array with 2D 32-bit unsigned integer complex fields;;
548;mat5_compressed_write.at:4181;Write cell array with 2D 16-bit signed integer complex fields;;
549;mat5_compressed_write.at:4260;Write cell array with 2D 16-bit unsigned integer complex fields;;
550;mat5_compressed_write.at:4339;Write cell array with 2D 8-bit signed integer complex fields;;
551;mat5_compressed_write.at:4418;Write cell array with 2D 8-bit unsigned integer complex fields;;
552;mat73_write.at:27;Write 2D double-precision array;;
553;mat73_write.at:70;Write 2D single-precision array;;
554;mat73_write.at:113;Write 2D 64-bit integer array;;
555;mat73_write.at:157;Write 2D 64-bit unsigned integer array;;
556;mat73_write.at:201;Write 2D 32-bit integer array;;
557;mat73_write.at:244;Write 2D 32-bit unsigned integer array;;
558;mat73_write.at:287;Write 2D 16-bit integer array;;
559;mat73_write.at:330;Write 2D 16-bit unsigned integer array;;
560;mat73_write.at:373;Write 2D 8-bit integer array;;
561;mat73_write.at:416;Write 2D 8-bit unsigned integer array;;
562;mat73_write.at:459;Write 2D double-precision complex array;;
563;mat73_write.at:502;Write 2D single-precision complex array;;
564;mat73_write.at:545;Write 2D 64-bit integer complex array;;
565;mat73_write.at:589;Write 2D 64-bit unsigned integer complex array;;
566;mat73_write.at:633;Write 2D 32-bit integer complex array;;
567;mat73_write.at:676;Write 2D 32-bit unsigned integer complex array;;
568;mat73_write.at:719;Write 2D 16-bit integer complex array;;
569;mat73_write.at:762;Write 2D 16-bit unsigned integer complex array;;
570;mat73_write.at:805;Write 2D 8-bit integer complex array;;
571;mat73_write.at:848;Write 2D 8-bit unsigned integer complex array;;
572;mat73_write.at:891;Write 2D sparse double-precision array;;
573;mat73_write.at:958;Write 2D sparse complex double-precision array;;
574;mat73_write.at:1025;Write 2D empty array;;
575;mat73_write.at:1062;Write character array;;
576;mat73_write.at:1104;Write empty structure array;;
577;mat73_write.at:1220;Write structure array with 2D double-precision fields;;
578;mat73_write.at:1303;Write structure array with 2D single-precision fields;;
579;mat73_write.at:1386;Write structure array with 2D 64-bit signed integer fields;;
580;mat73_write.at:1470;Write structure array with 2D 64-bit unsigned integer fields;;
581;mat73_write.at:1554;Write structure array with 2D 32-bit signed integer fields;;
582;mat73_write.at:1637;Write structure array with 2D 32-bit unsigned integer fields;;
583;mat73_write.at:1720;Write structure array with 2D 16-bit signed integer fields;;
584;mat73_write.at:1803;Write structure array with 2D 16-bit unsigned integer fields;;
585;mat73_write.at:1886;Write structure array with 2D 8-bit signed integer fields;;
586;mat73_write.at:1969;Write structure array with 2D 8-bit unsigned integer fields;;
587;mat73_write.at:2052;Write structure array with 2D double-precision complex fields;;
588;mat73_write.at:2135;Write structure array with 2D single-precision complex fields;;
589;mat73_write.at:2218;Write structure array with 2D 64-bit signed integer complex fields;;
590;mat73_write.at:2302;Write structure array with 2D 64-bit unsigned integer complex fields;;
591;mat73_write.at:2386;Write structure array with 2D 32-bit signed integer complex fields;;
592;mat73_write.at:2469;Write structure array with 2D 32-bit unsigned integer complex fields;;
593;mat73_write.at:2552;Write structure array with 2D 16-bit signed integer complex fields;;
594;mat73_write.at:2635;Write structure array with 2D 16-bit unsigned integer complex fields;;
595;mat73_write.at:2718;Write structure array with 2D 8-bit signed integer complex fields;;
596;mat73_write.at:2801;Write structure array with 2D 8-bit unsigned integer complex fields;;
597;mat73_write.at:2884;Write empty cell array;;
598;mat73_write.at:2940;Write cell array with 2D double-precision fields;;
599;mat73_write.at:3017;Write cell array with 2D single-precision fields;;
600;mat73_write.at:3094;Write cell array with 2D 64-bit signed integer fields;;
601;mat73_write.at:3172;Write cell array with 2D 64-bit unsigned integer fields;;
602;mat73_write.at:3250;Write cell array with 2D 32-bit signed integer fields;;
603;mat73_write.at:3327;Write cell array with 2D 32-bit unsigned integer fields;;
604;mat73_write.at:3404;Write cell array with 2D 16-bit signed integer fields;;
605;mat73_write.at:3481;Write cell array with 2D 16-bit unsigned integer fields;;
606;mat73_write.at:3558;Write cell array with 2D 8-bit signed integer fields;;
607;mat73_write.at:3635;Write cell array with 2D 8-bit unsigned integer fields;;
608;mat73_write.at:3712;Write cell array with 2D double-precision complex fields;;
609;mat73_write.at:3791;Write cell array with 2D single-precision complex fields;;
610;mat73_write.at:3870;Write cell array with 2D 64-bit signed integer complex fields;;
611;mat73_write.at:3950;Write cell array with 2D 64-bit unsigned integer complex fields;;
612;mat73_write.at:4030;Write cell array with 2D 32-bit signed integer complex fields;;
613;mat73_write.at:4109;Write cell array with 2D 32-bit unsigned integer complex fields;;
614;mat73_write.at:4188;Write cell array with 2D 16-bit signed integer complex fields;;
615;mat73_write.at:4267;Write cell array with 2D 16-bit unsigned integer complex fields;;
616;mat73_write.at:4346;Write cell array with 2D 8-bit signed integer complex fields;;
617;mat73_write.at:4425;Write cell array with 2D 8-bit unsigned integer complex fields;;
618;mat73_compressed_write.at:27;Write 2D double-precision array;;
619;mat73_compressed_write.at:71;Write 2D single-precision array;;
620;mat73_compressed_write.at:115;Write 2D 64-bit integer array;;
621;mat73_compressed_write.at:160;Write 2D 64-bit unsigned integer array;;
622;mat73_compressed_write.at:205;Write 2D 32-bit integer array;;
623;mat73_compressed_write.at:249;Write 2D 32-bit unsigned integer array;;
624;mat73_compressed_write.at:293;Write 2D 16-bit integer array;;
625;mat73_compressed_write.at:337;Write 2D 16-bit unsigned integer array;;
626;mat73_compressed_write.at:381;Write 2D 8-bit integer array;;
627;mat73_compressed_write.at:425;Write 2D 8-bit unsigned integer array;;
628;mat73_compressed_write.at:469;Write 2D double-precision complex array;;
629;mat73_compressed_write.at:513;Write 2D single-precision complex array;;
630;mat73_compressed_write.at:557;Write 2D 64-bit integer complex array;;
631;mat73_compressed_write.at:602;Write 2D 64-bit unsigned integer complex array;;
632;mat73_compressed_write.at:647;Write 2D 32-bit integer complex array;;
633;mat73_compressed_write.at:691;Write 2D 32-bit unsigned integer complex array;;
634;mat73_compressed_write.at:735;Write 2D 16-bit integer complex array;;
635;mat73_compressed_write.at:779;Write 2D 16-bit unsigned integer complex array;;
636;mat73_compressed_write.at:823;Write 2D 8-bit integer complex array;;
637;mat73_compressed_write.at:867;Write 2D 8-bit unsigned integer complex array;;
638;mat73_compressed_write.at:911;Write 2D sparse double-precision array;;
639;mat73_compressed_write.at:979;Write 2D sparse complex double-precision array;;
640;mat73_compressed_write.at:1047;Write 2D empty array;;
641;mat73_compressed_write.at:1085;Write character array;;
642;mat73_compressed_write.at:1128;Write empty structure array;;
643;mat73_compressed_write.at:1245;Write structure array with 2D double-precision fields;;
644;mat73_compressed_write.at:1329;Write structure array with 2D single-precision fields;;
645;mat73_compressed_write.at:1413;Write structure array with 2D 64-bit signed integer fields;;
646;mat73_compressed_write.at:1498;Write structure array with 2D 64-bit unsigned integer fields;;
647;mat73_compressed_write.at:1583;Write structure array with 2D 32-bit signed integer fields;;
648;mat73_compressed_write.at:1667;Write structure array with 2D 32-bit unsigned integer fields;;
649;mat73_compressed_write.at:1751;Write structure array with 2D 16-bit signed integer fields;;
650;mat73_compressed_write.at:1835;Write structure array with 2D 16-bit unsigned integer fields;;
651;mat73_compressed_write.at:1919;Write structure array with 2D 8-bit signed integer fields;;
652;mat73_compressed_write.at:2003;Write structure array with 2D 8-bit unsigned integer fields;;
653;mat73_compressed_write.at:2087;Write structure array with 2D double-precision complex fields;;
654;mat73_compressed_write.at:2171;Write structure array with 2D single-precision complex fields;;
655;mat73_compressed_write.at:2255;Write structure array with 2D 64-bit signed integer complex fields;;
656;mat73_compressed_write.at:2340;Write structure array with 2D 64-bit unsigned integer complex fields;;
657;mat73_compressed_write.at:2425;Write structure array with 2D 32-bit signed integer complex fields;;
658;mat73_compressed_write.at:2509;Write structure array with 2D 32-bit unsigned integer complex fields;;
659;mat73_compressed_write.at:2593;Write structure array with 2D 16-bit signed integer complex fields;;
660;mat73_compressed_write.at:2677;Write structure array with 2D 16-bit unsigned integer complex fields;;
661;mat73_compressed_write.at:2761;Write structure array with 2D 8-bit signed integer complex fields;;
662;mat73_compressed_write.at:2845;Write structure array with 2D 8-bit unsigned integer complex fields;;
663;mat73_compressed_write.at:2929;Write empty cell array;;
664;mat73_compressed_write.at:2986;Write cell array with 2D double-precision fields;;
665;mat73_compressed_write.at:3064;Write cell array with 2D single-precision fields;;
666;mat73_compressed_write.at:3142;Write cell array with 2D 64-bit signed integer fields;;
667;mat73_compressed_write.at:3221;Write cell array with 2D 64-bit unsigned integer fields;;
668;mat73_compressed_write.at:3300;Write cell array with 2D 32-bit signed integer fields;;
669;mat73_compressed_write.at:3378;Write cell array with 2D 32-bit unsigned integer fields;;
670;mat73_compressed_write.at:3456;Write cell array with 2D 16-bit signed integer fields;;
671;mat73_compressed_write.at:3534;Write cell array with 2D 16-bit unsigned integer fields;;
672;mat73_compressed_write.at:3612;Write cell array with 2D 8-bit signed integer fields;;
673;mat73_compressed_write.at:3690;Write cell array with 2D 8-bit unsigned integer fields;;
674;mat73_compressed_write.at:3768;Write cell array with 2D double-precision complex fields;;
675;mat73_compressed_write.at:3848;Write cell array with 2D single-precision complex fields;;
676;mat73_compressed_write.at:3928;Write cell array with 2D 64-bit signed integer complex fields;;
677;mat73_compressed_write.at:4009;Write cell array with 2D 64-bit unsigned integer complex fields;;
678;mat73_compressed_write.at:4090;Write cell array with 2D 32-bit signed integer complex fields;;
679;mat73_compressed_write.at:4170;Write cell array with 2D 32-bit unsigned integer complex fields;;
680;mat73_compressed_write.at:4250;Write cell array with 2D 16-bit signed integer complex fields;;
681;mat73_compressed_write.at:4330;Write cell array with 2D 16-bit unsigned integer complex fields;;
682;mat73_compressed_write.at:4410;Write cell array with 2D 8-bit signed integer complex fields;;
683;mat73_compressed_write.at:4490;Write cell array with 2D 8-bit unsigned integer complex fields;;
684;struct_api.at:27;Create structure array;struct_api;
685;struct_api.at:67;Set structure field;struct_api;
686;struct_api.at:158;Get structure fieldnames;struct_api;
687;struct_api.at:174;Add fields to structure array;struct_api;
688;struct_api.at:223;Linearly index a structure;struct_api;
689;struct_api.at:491;Index structure via dimension slices;struct_api;
690;cell_api.at:27;Set cell array elements;cell_api;
691;cell_api.at:132;Linearly index cell array;cell_api;
692;cell_api.at:265;Index cell array via dimension slices;cell_api;
"
# List of the all the test groups.
at_groups_all=`$as_echo "$at_help_all" | sed 's/;.*//'`

# at_fn_validate_ranges NAME...
# -----------------------------
# Validate and normalize the test group number contained in each variable
# NAME. Leading zeroes are treated as decimal.
at_fn_validate_ranges ()
{
  for at_grp
  do
    eval at_value=\$$at_grp
    if test $at_value -lt 1 || test $at_value -gt 692; then
      $as_echo "invalid test group: $at_value" >&2
      exit 1
    fi
    case $at_value in
      0*) # We want to treat leading 0 as decimal, like expr and test, but
	  # AS_VAR_ARITH treats it as octal if it uses $(( )).
	  # With XSI shells, ${at_value#${at_value%%[1-9]*}} avoids the
	  # expr fork, but it is not worth the effort to determine if the
	  # shell supports XSI when the user can just avoid leading 0.
	  eval $at_grp='`expr $at_value + 0`' ;;
    esac
  done
}

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

  case $at_option in
  *=?*) at_optarg=`expr "X$at_option" : '[^=]*=\(.*\)'` ;;
  *)    at_optarg= ;;
  esac

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

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

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

    --version | -V )
	at_version_p=:
	;;

    --clean | -c )
	at_clean=:
	;;

    --color )
	at_color=always
	;;
    --color=* )
	case $at_optarg in
	no | never | none) at_color=never ;;
	auto | tty | if-tty) at_color=auto ;;
	always | yes | force) at_color=always ;;
	*) at_optname=`echo " $at_option" | sed 's/^ //; s/=.*//'`
	   as_fn_error $? "unrecognized argument to $at_optname: $at_optarg" ;;
	esac
	;;

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

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

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

    --trace | -x )
	at_traceon='set -x'
	at_trace_echo=echo
	at_check_filter_trace=at_fn_filter_trace
	;;

    [0-9] | [0-9][0-9] | [0-9][0-9][0-9] | [0-9][0-9][0-9][0-9])
	at_fn_validate_ranges at_option
	as_fn_append at_groups "$at_option$as_nl"
	;;

    # Ranges
    [0-9]- | [0-9][0-9]- | [0-9][0-9][0-9]- | [0-9][0-9][0-9][0-9]-)
	at_range_start=`echo $at_option |tr -d X-`
	at_fn_validate_ranges at_range_start
	at_range=`$as_echo "$at_groups_all" | \
	  sed -ne '/^'$at_range_start'$/,$p'`
	as_fn_append at_groups "$at_range$as_nl"
	;;

    -[0-9] | -[0-9][0-9] | -[0-9][0-9][0-9] | -[0-9][0-9][0-9][0-9])
	at_range_end=`echo $at_option |tr -d X-`
	at_fn_validate_ranges at_range_end
	at_range=`$as_echo "$at_groups_all" | \
	  sed -ne '1,/^'$at_range_end'$/p'`
	as_fn_append at_groups "$at_range$as_nl"
	;;

    [0-9]-[0-9] | [0-9]-[0-9][0-9] | [0-9]-[0-9][0-9][0-9] | \
    [0-9]-[0-9][0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9] | \
    [0-9][0-9]-[0-9][0-9][0-9] | [0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9] | \
    [0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] | \
    [0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9] )
	at_range_start=`expr $at_option : '\(.*\)-'`
	at_range_end=`expr $at_option : '.*-\(.*\)'`
	if test $at_range_start -gt $at_range_end; then
	  at_tmp=$at_range_end
	  at_range_end=$at_range_start
	  at_range_start=$at_tmp
	fi
	at_fn_validate_ranges at_range_start at_range_end
	at_range=`$as_echo "$at_groups_all" | \
	  sed -ne '/^'$at_range_start'$/,/^'$at_range_end'$/p'`
	as_fn_append at_groups "$at_range$as_nl"
	;;

    # Directory selection.
    --directory | -C )
	at_prev=--directory
	;;
    --directory=* )
	at_change_dir=:
	at_dir=$at_optarg
	if test x- = "x$at_dir" ; then
	  at_dir=./-
	fi
	;;

    # Parallel execution.
    --jobs | -j )
	at_jobs=0
	;;
    --jobs=* | -j[0-9]* )
	if test -n "$at_optarg"; then
	  at_jobs=$at_optarg
	else
	  at_jobs=`expr X$at_option : 'X-j\(.*\)'`
	fi
	case $at_jobs in *[!0-9]*)
	  at_optname=`echo " $at_option" | sed 's/^ //; s/[0-9=].*//'`
	  as_fn_error $? "non-numeric argument to $at_optname: $at_jobs" ;;
	esac
	;;

    # Keywords.
    --keywords | -k )
	at_prev=--keywords
	;;
    --keywords=* )
	at_groups_selected=$at_help_all
	at_save_IFS=$IFS
	IFS=,
	set X $at_optarg
	shift
	IFS=$at_save_IFS
	for at_keyword
	do
	  at_invert=
	  case $at_keyword in
	  '!'*)
	    at_invert="-v"
	    at_keyword=`expr "X$at_keyword" : 'X!\(.*\)'`
	    ;;
	  esac
	  # It is on purpose that we match the test group titles too.
	  at_groups_selected=`$as_echo "$at_groups_selected" |
	      grep -i $at_invert "^[1-9][^;]*;.*[; ]$at_keyword[ ;]"`
	done
	# Smash the keywords.
	at_groups_selected=`$as_echo "$at_groups_selected" | sed 's/;.*//'`
	as_fn_append at_groups "$at_groups_selected$as_nl"
	;;
    --recheck)
	at_recheck=:
	;;

    *=*)
	at_envvar=`expr "x$at_option" : 'x\([^=]*\)='`
	# Reject names that are not valid shell variable names.
	case $at_envvar in
	  '' | [0-9]* | *[!_$as_cr_alnum]* )
	    as_fn_error $? "invalid variable name: \`$at_envvar'" ;;
	esac
	at_value=`$as_echo "$at_optarg" | sed "s/'/'\\\\\\\\''/g"`
	# Export now, but save eval for later and for debug scripts.
	export $at_envvar
	as_fn_append at_debug_args " $at_envvar='$at_value'"
	;;

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

# Verify our last option didn't require an argument
if test -n "$at_prev"; then :
  as_fn_error $? "\`$at_prev' requires an argument"
fi

# The file containing the suite.
at_suite_log=$at_dir/$as_me.log

# Selected test groups.
if test -z "$at_groups$at_recheck"; then
  at_groups=$at_groups_all
else
  if test -n "$at_recheck" && test -r "$at_suite_log"; then
    at_oldfails=`sed -n '
      /^Failed tests:$/,/^Skipped tests:$/{
	s/^[ ]*\([1-9][0-9]*\):.*/\1/p
      }
      /^Unexpected passes:$/,/^## Detailed failed tests/{
	s/^[ ]*\([1-9][0-9]*\):.*/\1/p
      }
      /^## Detailed failed tests/q
      ' "$at_suite_log"`
    as_fn_append at_groups "$at_oldfails$as_nl"
  fi
  # Sort the tests, removing duplicates.
  at_groups=`$as_echo "$at_groups" | sort -nu | sed '/^$/d'`
fi

if test x"$at_color" = xalways \
   || { test x"$at_color" = xauto && test -t 1; }; then
  at_red=`printf '\033[0;31m'`
  at_grn=`printf '\033[0;32m'`
  at_lgn=`printf '\033[1;32m'`
  at_blu=`printf '\033[1;34m'`
  at_std=`printf '\033[m'`
else
  at_red= at_grn= at_lgn= at_blu= at_std=
fi

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

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

Do not change environment variables directly.  Instead, set them via
command line arguments.  Set \`AUTOTEST_PATH' to select the executables
to exercise.  Each relative directory is expanded as build and source
directories relative to the top level of this distribution.
E.g., from within the build directory /tmp/foo-1.0, invoking this:

  $ $0 AUTOTEST_PATH=bin

is equivalent to the following, assuming the source directory is /src/foo-1.0:

  PATH=/tmp/foo-1.0/bin:/src/foo-1.0/bin:\$PATH $0
_ATEOF
cat <<_ATEOF || at_write_fail=1

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

Execution tuning:
  -C, --directory=DIR
                 change to directory DIR before starting
      --color[=never|auto|always]
                 disable colored test results, or enable even without terminal
  -j, --jobs[=N]
                 Allow N jobs at once; infinite jobs with no arg (default 1)
  -k, --keywords=KEYWORDS
                 select the tests matching all the comma-separated KEYWORDS
                 multiple \`-k' accumulate; prefixed \`!' negates a KEYWORD
      --recheck  select all tests that failed or passed unexpectedly last time
  -e, --errexit  abort as soon as a test fails; implies --debug
  -v, --verbose  force more detailed output
                 default for debugging scripts
  -d, --debug    inhibit clean up and top-level logging
                 default for debugging scripts
  -x, --trace    enable tests shell tracing
_ATEOF
cat <<_ATEOF || at_write_fail=1

Report bugs to <chulbe2lsu@users.sourceforge.net>.
_ATEOF
  exit $at_write_fail
fi

# List of tests.
if $at_list_p; then
  cat <<_ATEOF || at_write_fail=1
MATIO 1.5.0 test suite: matio testsuite test groups:

 NUM: FILE-NAME:LINE     TEST-GROUP-NAME
      KEYWORDS

_ATEOF
  # Pass an empty line as separator between selected groups and help.
  $as_echo "$at_groups$as_nl$as_nl$at_help_all" |
    awk 'NF == 1 && FS != ";" {
	   selected[$ 1] = 1
	   next
	 }
	 /^$/ { FS = ";" }
	 NF > 0 {
	   if (selected[$ 1]) {
	     printf " %3d: %-18s %s\n", $ 1, $ 2, $ 3
	     if ($ 4) {
	       lmax = 79
	       indent = "     "
	       line = indent
	       len = length (line)
	       n = split ($ 4, a, " ")
	       for (i = 1; i <= n; i++) {
		 l = length (a[i]) + 1
		 if (i > 1 && len + l > lmax) {
		   print line
		   line = indent " " a[i]
		   len = length (line)
		 } else {
		   line = line " " a[i]
		   len += l
		 }
	       }
	       if (n)
		 print line
	     }
	   }
	 }' || at_write_fail=1
  exit $at_write_fail
fi
if $at_version_p; then
  $as_echo "$as_me (MATIO 1.5.0)" &&
  cat <<\_ATEOF || at_write_fail=1

Copyright (C) 2010 Free Software Foundation, Inc.
This test suite is free software; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
_ATEOF
  exit $at_write_fail
fi

# Should we print banners?  Yes if more than one test is run.
case $at_groups in #(
  *$as_nl* )
      at_print_banners=: ;; #(
  * ) at_print_banners=false ;;
esac
# Text for banner N, set to a single space once printed.
# Banner 1. testsuite.at:60
# Category starts at test group 1.
at_banner_text_1="Read MAT version 4 (Little Endian)"
# Banner 2. testsuite.at:63
# Category starts at test group 4.
at_banner_text_2="Read MAT version 4 (Big Endian)"
# Banner 3. testsuite.at:66
# Category starts at test group 7.
at_banner_text_3="Read Uncompressed MAT version 5 (Little Endian)"
# Banner 4. testsuite.at:69
# Category starts at test group 76.
at_banner_text_4="Read Compressed MAT version 5 (Little Endian)"
# Banner 5. testsuite.at:72
# Category starts at test group 145.
at_banner_text_5="Read Uncompressed MAT version 5 (Big Endian)"
# Banner 6. testsuite.at:75
# Category starts at test group 214.
at_banner_text_6="Read Compressed MAT version 5 (Big Endian)"
# Banner 7. testsuite.at:78
# Category starts at test group 283.
at_banner_text_7="Read MAT version 7.3 (HDF5 Schema 1) (Little Endian)"
# Banner 8. testsuite.at:81
# Category starts at test group 352.
at_banner_text_8="Read MAT version 7.3 (HDF5 Schema 1) (Big Endian)"
# Banner 9. testsuite.at:84
# Category starts at test group 420.
at_banner_text_9="Write Uncompressed MAT version 5"
# Banner 10. testsuite.at:87
# Category starts at test group 486.
at_banner_text_10="Write Compressed MAT version 5"
# Banner 11. testsuite.at:90
# Category starts at test group 552.
at_banner_text_11="Write MAT version 7.3"
# Banner 12. testsuite.at:93
# Category starts at test group 618.
at_banner_text_12="Write Compressed MAT version 7.3"
# Banner 13. testsuite.at:96
# Category starts at test group 684.
at_banner_text_13="API Tests"

# Take any -C into account.
if $at_change_dir ; then
  test x != "x$at_dir" && cd "$at_dir" \
    || as_fn_error $? "unable to change directory"
  at_dir=`pwd`
fi

# Load the config files for any default variable assignments.
for at_file in atconfig atlocal
do
  test -r $at_file || continue
  . ./$at_file || as_fn_error $? "invalid content: $at_file"
done

# Autoconf <=2.59b set at_top_builddir instead of at_top_build_prefix:
: "${at_top_build_prefix=$at_top_builddir}"

# Perform any assignments requested during argument parsing.
eval "$at_debug_args"

# atconfig delivers names relative to the directory the test suite is
# in, but the groups themselves are run in testsuite-dir/group-dir.
if test -n "$at_top_srcdir"; then
  builddir=../..
  for at_dir_var in srcdir top_srcdir top_build_prefix
  do
    eval at_val=\$at_$at_dir_var
    case $at_val in
      [\\/$]* | ?:[\\/]* ) at_prefix= ;;
      *) at_prefix=../../ ;;
    esac
    eval "$at_dir_var=\$at_prefix\$at_val"
  done
fi

## -------------------- ##
## Directory structure. ##
## -------------------- ##

# This is the set of directories and files used by this script
# (non-literals are capitalized):
#
# TESTSUITE         - the testsuite
# TESTSUITE.log     - summarizes the complete testsuite run
# TESTSUITE.dir/    - created during a run, remains after -d or failed test
# + at-groups/      - during a run: status of all groups in run
# | + NNN/          - during a run: meta-data about test group NNN
# | | + check-line  - location (source file and line) of current AT_CHECK
# | | + status      - exit status of current AT_CHECK
# | | + stdout      - stdout of current AT_CHECK
# | | + stder1      - stderr, including trace
# | | + stderr      - stderr, with trace filtered out
# | | + test-source - portion of testsuite that defines group
# | | + times       - timestamps for computing duration
# | | + pass        - created if group passed
# | | + xpass       - created if group xpassed
# | | + fail        - created if group failed
# | | + xfail       - created if group xfailed
# | | + skip        - created if group skipped
# + at-stop         - during a run: end the run if this file exists
# + at-source-lines - during a run: cache of TESTSUITE line numbers for extraction
# + 0..NNN/         - created for each group NNN, remains after -d or failed test
# | + TESTSUITE.log - summarizes the group results
# | + ...           - files created during the group

# The directory the whole suite works in.
# Should be absolute to let the user `cd' at will.
at_suite_dir=$at_dir/$as_me.dir
# The file containing the suite ($at_dir might have changed since earlier).
at_suite_log=$at_dir/$as_me.log
# The directory containing helper files per test group.
at_helper_dir=$at_suite_dir/at-groups
# Stop file: if it exists, do not start new jobs.
at_stop_file=$at_suite_dir/at-stop
# The fifo used for the job dispatcher.
at_job_fifo=$at_suite_dir/at-job-fifo

if $at_clean; then
  test -d "$at_suite_dir" &&
    find "$at_suite_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
  rm -f -r "$at_suite_dir" "$at_suite_log"
  exit $?
fi

# Don't take risks: use only absolute directories in PATH.
#
# For stand-alone test suites (ie. atconfig was not found),
# AUTOTEST_PATH is relative to `.'.
#
# For embedded test suites, AUTOTEST_PATH is relative to the top level
# of the package.  Then expand it into build/src parts, since users
# may create executables in both places.
AUTOTEST_PATH=`$as_echo "$AUTOTEST_PATH" | sed "s|:|$PATH_SEPARATOR|g"`
at_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $AUTOTEST_PATH $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -n "$at_path" && as_fn_append at_path $PATH_SEPARATOR
case $as_dir in
  [\\/]* | ?:[\\/]* )
    as_fn_append at_path "$as_dir"
    ;;
  * )
    if test -z "$at_top_build_prefix"; then
      # Stand-alone test suite.
      as_fn_append at_path "$as_dir"
    else
      # Embedded test suite.
      as_fn_append at_path "$at_top_build_prefix$as_dir$PATH_SEPARATOR"
      as_fn_append at_path "$at_top_srcdir/$as_dir"
    fi
    ;;
esac
  done
IFS=$as_save_IFS


# Now build and simplify PATH.
#
# There might be directories that don't exist, but don't redirect
# builtins' (eg., cd) stderr directly: Ultrix's sh hates that.
at_new_path=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $at_path
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -d "$as_dir" || continue
case $as_dir in
  [\\/]* | ?:[\\/]* ) ;;
  * ) as_dir=`(cd "$as_dir" && pwd) 2>/dev/null` ;;
esac
case $PATH_SEPARATOR$at_new_path$PATH_SEPARATOR in
  *$PATH_SEPARATOR$as_dir$PATH_SEPARATOR*) ;;
  $PATH_SEPARATOR$PATH_SEPARATOR) at_new_path=$as_dir ;;
  *) as_fn_append at_new_path "$PATH_SEPARATOR$as_dir" ;;
esac
  done
IFS=$as_save_IFS

PATH=$at_new_path
export PATH

# Setting up the FDs.



# 5 is the log file.  Not to be overwritten if `-d'.
if $at_debug_p; then
  at_suite_log=/dev/null
else
  : >"$at_suite_log"
fi
exec 5>>"$at_suite_log"

# Banners and logs.
$as_echo "## ---------------------------------------- ##
## MATIO 1.5.0 test suite: matio testsuite. ##
## ---------------------------------------- ##"
{
  $as_echo "## ---------------------------------------- ##
## MATIO 1.5.0 test suite: matio testsuite. ##
## ---------------------------------------- ##"
  echo

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

  # If ChangeLog exists, list a few lines in case it might help determining
  # the exact version.
  if test -n "$at_top_srcdir" && test -f "$at_top_srcdir/ChangeLog"; then
    $as_echo "## ---------- ##
## ChangeLog. ##
## ---------- ##"
    echo
    sed 's/^/| /;10q' "$at_top_srcdir/ChangeLog"
    echo
  fi

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

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

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

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

_ASUNAME

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

}
  echo

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


## ------------------------- ##
## Autotest shell functions. ##
## ------------------------- ##

# at_fn_banner NUMBER
# -------------------
# Output banner NUMBER, provided the testsuite is running multiple groups and
# this particular banner has not yet been printed.
at_fn_banner ()
{
  $at_print_banners || return 0
  eval at_banner_text=\$at_banner_text_$1
  test "x$at_banner_text" = "x " && return 0
  eval "at_banner_text_$1=\" \""
  if test -z "$at_banner_text"; then
    $at_first || echo
  else
    $as_echo "$as_nl$at_banner_text$as_nl"
  fi
} # at_fn_banner

# at_fn_check_prepare_notrace REASON LINE
# ---------------------------------------
# Perform AT_CHECK preparations for the command at LINE for an untraceable
# command; REASON is the reason for disabling tracing.
at_fn_check_prepare_notrace ()
{
  $at_trace_echo "Not enabling shell tracing (command contains $1)"
  $as_echo "$2" >"$at_check_line_file"
  at_check_trace=: at_check_filter=:
  : >"$at_stdout"; : >"$at_stderr"
}

# at_fn_check_prepare_trace LINE
# ------------------------------
# Perform AT_CHECK preparations for the command at LINE for a traceable
# command.
at_fn_check_prepare_trace ()
{
  $as_echo "$1" >"$at_check_line_file"
  at_check_trace=$at_traceon at_check_filter=$at_check_filter_trace
  : >"$at_stdout"; : >"$at_stderr"
}

# at_fn_check_prepare_dynamic COMMAND LINE
# ----------------------------------------
# Decide if COMMAND at LINE is traceable at runtime, and call the appropriate
# preparation function.
at_fn_check_prepare_dynamic ()
{
  case $1 in
    *$as_nl*)
      at_fn_check_prepare_notrace 'an embedded newline' "$2" ;;
    *)
      at_fn_check_prepare_trace "$2" ;;
  esac
}

# at_fn_filter_trace
# ------------------
# Remove the lines in the file "$at_stderr" generated by "set -x" and print
# them to stderr.
at_fn_filter_trace ()
{
  mv "$at_stderr" "$at_stder1"
  grep '^ *+' "$at_stder1" >&2
  grep -v '^ *+' "$at_stder1" >"$at_stderr"
}

# at_fn_log_failure FILE-LIST
# ---------------------------
# Copy the files in the list on stdout with a "> " prefix, and exit the shell
# with a failure exit code.
at_fn_log_failure ()
{
  for file
    do $as_echo "$file:"; sed 's/^/> /' "$file"; done
  echo 1 > "$at_status_file"
  exit 1
}

# at_fn_check_skip EXIT-CODE LINE
# -------------------------------
# Check whether EXIT-CODE is a special exit code (77 or 99), and if so exit
# the test group subshell with that same exit code. Use LINE in any report
# about test failure.
at_fn_check_skip ()
{
  case $1 in
    99) echo 99 > "$at_status_file"; at_failed=:
	$as_echo "$2: hard failure"; exit 99;;
    77) echo 77 > "$at_status_file"; exit 77;;
  esac
}

# at_fn_check_status EXPECTED EXIT-CODE LINE
# ------------------------------------------
# Check whether EXIT-CODE is the EXPECTED exit code, and if so do nothing.
# Otherwise, if it is 77 or 99, exit the test group subshell with that same
# exit code; if it is anything else print an error message referring to LINE,
# and fail the test.
at_fn_check_status ()
{
  case $2 in
    $1 ) ;;
    77) echo 77 > "$at_status_file"; exit 77;;
    99) echo 99 > "$at_status_file"; at_failed=:
	$as_echo "$3: hard failure"; exit 99;;
    *) $as_echo "$3: exit code was $2, expected $1"
      at_failed=:;;
  esac
}

# at_fn_diff_devnull FILE
# -----------------------
# Emit a diff between /dev/null and FILE. Uses "test -s" to avoid useless diff
# invocations.
at_fn_diff_devnull ()
{
  test -s "$1" || return 0
  $at_diff "$at_devnull" "$1"
}

# at_fn_test NUMBER
# -----------------
# Parse out test NUMBER from the tail of this file.
at_fn_test ()
{
  eval at_sed=\$at_sed$1
  sed "$at_sed" "$at_myself" > "$at_test_source"
}

# at_fn_create_debugging_script
# -----------------------------
# Create the debugging script $at_group_dir/run which will reproduce the
# current test group.
at_fn_create_debugging_script ()
{
  {
    echo "#! /bin/sh" &&
    echo 'test "${ZSH_VERSION+set}" = set && alias -g '\''${1+"$@"}'\''='\''"$@"'\''' &&
    $as_echo "cd '$at_dir'" &&
    $as_echo "exec \${CONFIG_SHELL-$SHELL} \"$at_myself\" -v -d $at_debug_args $at_group \${1+\"\$@\"}" &&
    echo 'exit 1'
  } >"$at_group_dir/run" &&
  chmod +x "$at_group_dir/run"
}

## -------------------------------- ##
## End of autotest shell functions. ##
## -------------------------------- ##
{
  $as_echo "## ---------------- ##
## Tested programs. ##
## ---------------- ##"
  echo
} >&5

# Report what programs are being tested.
for at_program in : $at_tested
do
  test "$at_program" = : && continue
  case $at_program in
    [\\/]* | ?:[\\/]* ) $at_program_=$at_program ;;
    * )
    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    test -f "$as_dir/$at_program" && break
  done
IFS=$as_save_IFS

    at_program_=$as_dir/$at_program ;;
  esac
  if test -f "$at_program_"; then
    {
      $as_echo "$at_srcdir/testsuite.at:27: $at_program_ --version"
      "$at_program_" --version </dev/null
      echo
    } >&5 2>&1
  else
    as_fn_error $? "cannot find $at_program" "$LINENO" 5
  fi
done

{
  $as_echo "## ------------------ ##
## Running the tests. ##
## ------------------ ##"
} >&5

at_start_date=`date`
at_start_time=`date +%s 2>/dev/null`
$as_echo "$as_me: starting at: $at_start_date" >&5

# Check for libtool configuration data
# host_os and with_msvc_ld are used in MATIO_AT_HOST_DATA
eval `$LIBTOOL --config | grep '^EGREP='`
eval `$LIBTOOL --config | $EGREP '^(host_os|with_msvc_ld)='`

# Create the master directory if it doesn't already exist.
as_dir="$at_suite_dir"; as_fn_mkdir_p ||
  as_fn_error $? "cannot create \`$at_suite_dir'" "$LINENO" 5

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

# Use `diff -u' when possible.
if at_diff=`diff -u "$at_devnull" "$at_devnull" 2>&1` && test -z "$at_diff"
then
  at_diff='diff -u'
else
  at_diff=diff
fi

# Get the last needed group.
for at_group in : $at_groups; do :; done

# Extract the start and end lines of each test group at the tail
# of this file
awk '
BEGIN { FS="" }
/^#AT_START_/ {
  start = NR
}
/^#AT_STOP_/ {
  test = substr ($ 0, 10)
  print "at_sed" test "=\"1," start "d;" (NR-1) "q\""
  if (test == "'"$at_group"'") exit
}' "$at_myself" > "$at_suite_dir/at-source-lines" &&
. "$at_suite_dir/at-source-lines" ||
  as_fn_error $? "cannot create test line number cache" "$LINENO" 5
rm -f "$at_suite_dir/at-source-lines"

# Set number of jobs for `-j'; avoid more jobs than test groups.
set X $at_groups; shift; at_max_jobs=$#
if test $at_max_jobs -eq 0; then
  at_jobs=1
fi
if test $at_jobs -ne 1 &&
   { test $at_jobs -eq 0 || test $at_jobs -gt $at_max_jobs; }; then
  at_jobs=$at_max_jobs
fi

# If parallel mode, don't output banners, don't split summary lines.
if test $at_jobs -ne 1; then
  at_print_banners=false
  at_quiet=:
fi

# Set up helper dirs.
rm -rf "$at_helper_dir" &&
mkdir "$at_helper_dir" &&
cd "$at_helper_dir" &&
{ test -z "$at_groups" || mkdir $at_groups; } ||
as_fn_error $? "testsuite directory setup failed" "$LINENO" 5

# Functions for running a test group.  We leave the actual
# test group execution outside of a shell function in order
# to avoid hitting zsh 4.x exit status bugs.

# at_fn_group_prepare
# -------------------
# Prepare for running a test group.
at_fn_group_prepare ()
{
  # The directory for additional per-group helper files.
  at_job_dir=$at_helper_dir/$at_group
  # The file containing the location of the last AT_CHECK.
  at_check_line_file=$at_job_dir/check-line
  # The file containing the exit status of the last command.
  at_status_file=$at_job_dir/status
  # The files containing the output of the tested commands.
  at_stdout=$at_job_dir/stdout
  at_stder1=$at_job_dir/stder1
  at_stderr=$at_job_dir/stderr
  # The file containing the code for a test group.
  at_test_source=$at_job_dir/test-source
  # The file containing dates.
  at_times_file=$at_job_dir/times

  # Be sure to come back to the top test directory.
  cd "$at_suite_dir"

  # Clearly separate the test groups when verbose.
  $at_first || $at_verbose echo

  at_group_normalized=$at_group

  eval 'while :; do
    case $at_group_normalized in #(
    '"$at_format"'*) break;;
    esac
    at_group_normalized=0$at_group_normalized
  done'


  # Create a fresh directory for the next test group, and enter.
  # If one already exists, the user may have invoked ./run from
  # within that directory; we remove the contents, but not the
  # directory itself, so that we aren't pulling the rug out from
  # under the shell's notion of the current directory.
  at_group_dir=$at_suite_dir/$at_group_normalized
  at_group_log=$at_group_dir/$as_me.log
  if test -d "$at_group_dir"; then
  find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx {} \;
  rm -fr "$at_group_dir"/* "$at_group_dir"/.[!.] "$at_group_dir"/.??*
fi ||
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: test directory for $at_group_normalized could not be cleaned" >&5
$as_echo "$as_me: WARNING: test directory for $at_group_normalized could not be cleaned" >&2;}
  # Be tolerant if the above `rm' was not able to remove the directory.
  as_dir="$at_group_dir"; as_fn_mkdir_p

  echo 0 > "$at_status_file"

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

# at_fn_group_banner ORDINAL LINE DESC PAD [BANNER]
# -------------------------------------------------
# Declare the test group ORDINAL, located at LINE with group description DESC,
# and residing under BANNER. Use PAD to align the status column.
at_fn_group_banner ()
{
  at_setup_line="$2"
  test -n "$5" && at_fn_banner $5
  at_desc="$3"
  case $1 in
    [0-9])      at_desc_line="  $1: ";;
    [0-9][0-9]) at_desc_line=" $1: " ;;
    *)          at_desc_line="$1: "  ;;
  esac
  as_fn_append at_desc_line "$3$4"
  $at_quiet $as_echo_n "$at_desc_line"
  echo "#                             -*- compilation -*-" >> "$at_group_log"
}

# at_fn_group_postprocess
# -----------------------
# Perform cleanup after running a test group.
at_fn_group_postprocess ()
{
  # Be sure to come back to the suite directory, in particular
  # since below we might `rm' the group directory we are in currently.
  cd "$at_suite_dir"

  if test ! -f "$at_check_line_file"; then
    sed "s/^ */$as_me: WARNING: /" <<_ATEOF
      A failure happened in a test group before any test could be
      run. This means that test suite is improperly designed.  Please
      report this failure to <chulbe2lsu@users.sourceforge.net>.
_ATEOF
    $as_echo "$at_setup_line" >"$at_check_line_file"
    at_status=99
  fi
  $at_verbose $as_echo_n "$at_group. $at_setup_line: "
  $as_echo_n "$at_group. $at_setup_line: " >> "$at_group_log"
  case $at_xfail:$at_status in
    yes:0)
	at_msg="UNEXPECTED PASS"
	at_res=xpass
	at_errexit=$at_errexit_p
	at_color=$at_red
	;;
    no:0)
	at_msg="ok"
	at_res=pass
	at_errexit=false
	at_color=$at_grn
	;;
    *:77)
	at_msg='skipped ('`cat "$at_check_line_file"`')'
	at_res=skip
	at_errexit=false
	at_color=$at_blu
	;;
    no:* | *:99)
	at_msg='FAILED ('`cat "$at_check_line_file"`')'
	at_res=fail
	at_errexit=$at_errexit_p
	at_color=$at_red
	;;
    yes:*)
	at_msg='expected failure ('`cat "$at_check_line_file"`')'
	at_res=xfail
	at_errexit=false
	at_color=$at_lgn
	;;
  esac
  echo "$at_res" > "$at_job_dir/$at_res"
  # In parallel mode, output the summary line only afterwards.
  if test $at_jobs -ne 1 && test -n "$at_verbose"; then
    $as_echo "$at_desc_line $at_color$at_msg$at_std"
  else
    # Make sure there is a separator even with long titles.
    $as_echo " $at_color$at_msg$at_std"
  fi
  at_log_msg="$at_group. $at_desc ($at_setup_line): $at_msg"
  case $at_status in
    0|77)
      # $at_times_file is only available if the group succeeded.
      # We're not including the group log, so the success message
      # is written in the global log separately.  But we also
      # write to the group log in case they're using -d.
      if test -f "$at_times_file"; then
	at_log_msg="$at_log_msg     ("`sed 1d "$at_times_file"`')'
	rm -f "$at_times_file"
      fi
      $as_echo "$at_log_msg" >> "$at_group_log"
      $as_echo "$at_log_msg" >&5

      # Cleanup the group directory, unless the user wants the files
      # or the success was unexpected.
      if $at_debug_p || test $at_res = xpass; then
	at_fn_create_debugging_script
	if test $at_res = xpass && $at_errexit; then
	  echo stop > "$at_stop_file"
	fi
      else
	if test -d "$at_group_dir"; then
	  find "$at_group_dir" -type d ! -perm -700 -exec chmod u+rwx \{\} \;
	  rm -fr "$at_group_dir"
	fi
	rm -f "$at_test_source"
      fi
      ;;
    *)
      # Upon failure, include the log into the testsuite's global
      # log.  The failure message is written in the group log.  It
      # is later included in the global log.
      $as_echo "$at_log_msg" >> "$at_group_log"

      # Upon failure, keep the group directory for autopsy, and create
      # the debugging script.  With -e, do not start any further tests.
      at_fn_create_debugging_script
      if $at_errexit; then
	echo stop > "$at_stop_file"
      fi
      ;;
  esac
}


## ------------ ##
## Driver loop. ##
## ------------ ##


if (set -m && set +m && set +b) >/dev/null 2>&1; then
  set +b
  at_job_control_on='set -m' at_job_control_off='set +m' at_job_group=-
else
  at_job_control_on=: at_job_control_off=: at_job_group=
fi

for at_signal in 1 2 15; do
  trap 'set +x; set +e
	$at_job_control_off
	at_signal='"$at_signal"'
	echo stop > "$at_stop_file"
	trap "" $at_signal
	at_pgids=
	for at_pgid in `jobs -p 2>/dev/null`; do
	  at_pgids="$at_pgids $at_job_group$at_pgid"
	done
	test -z "$at_pgids" || kill -$at_signal $at_pgids 2>/dev/null
	wait
	if test "$at_jobs" -eq 1 || test -z "$at_verbose"; then
	  echo >&2
	fi
	at_signame=`kill -l $at_signal 2>&1 || echo $at_signal`
	set x $at_signame
	test 1 -gt 2 && at_signame=$at_signal
	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: caught signal $at_signame, bailing out" >&5
$as_echo "$as_me: WARNING: caught signal $at_signame, bailing out" >&2;}
	as_fn_arith 128 + $at_signal && exit_status=$as_val
	as_fn_exit $exit_status' $at_signal
done

rm -f "$at_stop_file"
at_first=:

if test $at_jobs -ne 1 &&
     rm -f "$at_job_fifo" &&
     test -n "$at_job_group" &&
     ( mkfifo "$at_job_fifo" && trap 'exit 1' PIPE STOP TSTP ) 2>/dev/null
then
  # FIFO job dispatcher.

  trap 'at_pids=
	for at_pid in `jobs -p`; do
	  at_pids="$at_pids $at_job_group$at_pid"
	done
	if test -n "$at_pids"; then
	  at_sig=TSTP
	  test "${TMOUT+set}" = set && at_sig=STOP
	  kill -$at_sig $at_pids 2>/dev/null
	fi
	kill -STOP $$
	test -z "$at_pids" || kill -CONT $at_pids 2>/dev/null' TSTP

  echo
  # Turn jobs into a list of numbers, starting from 1.
  at_joblist=`$as_echo "$at_groups" | sed -n 1,${at_jobs}p`

  set X $at_joblist
  shift
  for at_group in $at_groups; do
    $at_job_control_on 2>/dev/null
    (
      # Start one test group.
      $at_job_control_off
      if $at_first; then
	exec 7>"$at_job_fifo"
      else
	exec 6<&-
      fi
      trap 'set +x; set +e
	    trap "" PIPE
	    echo stop > "$at_stop_file"
	    echo >&7
	    as_fn_exit 141' PIPE
      at_fn_group_prepare
      if cd "$at_group_dir" &&
	 at_fn_test $at_group &&
	 . "$at_test_source"
      then :; else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5
$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;}
	at_failed=:
      fi
      at_fn_group_postprocess
      echo >&7
    ) &
    $at_job_control_off
    if $at_first; then
      at_first=false
      exec 6<"$at_job_fifo" 7>"$at_job_fifo"
    fi
    shift # Consume one token.
    if test $# -gt 0; then :; else
      read at_token <&6 || break
      set x $*
    fi
    test -f "$at_stop_file" && break
  done
  exec 7>&-
  # Read back the remaining ($at_jobs - 1) tokens.
  set X $at_joblist
  shift
  if test $# -gt 0; then
    shift
    for at_job
    do
      read at_token
    done <&6
  fi
  exec 6<&-
  wait
else
  # Run serially, avoid forks and other potential surprises.
  for at_group in $at_groups; do
    at_fn_group_prepare
    if cd "$at_group_dir" &&
       at_fn_test $at_group &&
       . "$at_test_source"; then :; else
      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unable to parse test group: $at_group" >&5
$as_echo "$as_me: WARNING: unable to parse test group: $at_group" >&2;}
      at_failed=:
    fi
    at_fn_group_postprocess
    test -f "$at_stop_file" && break
    at_first=false
  done
fi

# Wrap up the test suite with summary statistics.
cd "$at_helper_dir"

# Use ?..???? when the list must remain sorted, the faster * otherwise.
at_pass_list=`for f in */pass; do echo $f; done | sed '/\*/d; s,/pass,,'`
at_skip_list=`for f in */skip; do echo $f; done | sed '/\*/d; s,/skip,,'`
at_xfail_list=`for f in */xfail; do echo $f; done | sed '/\*/d; s,/xfail,,'`
at_xpass_list=`for f in ?/xpass ??/xpass ???/xpass ????/xpass; do
		 echo $f; done | sed '/?/d; s,/xpass,,'`
at_fail_list=`for f in ?/fail ??/fail ???/fail ????/fail; do
		echo $f; done | sed '/?/d; s,/fail,,'`

set X $at_pass_list $at_xpass_list $at_xfail_list $at_fail_list $at_skip_list
shift; at_group_count=$#
set X $at_xpass_list; shift; at_xpass_count=$#; at_xpass_list=$*
set X $at_xfail_list; shift; at_xfail_count=$#
set X $at_fail_list; shift; at_fail_count=$#; at_fail_list=$*
set X $at_skip_list; shift; at_skip_count=$#

as_fn_arith $at_group_count - $at_skip_count && at_run_count=$as_val
as_fn_arith $at_xpass_count + $at_fail_count && at_unexpected_count=$as_val
as_fn_arith $at_xfail_count + $at_fail_count && at_total_fail_count=$as_val

# Back to the top directory.
cd "$at_dir"
rm -rf "$at_helper_dir"

# Compute the duration of the suite.
at_stop_date=`date`
at_stop_time=`date +%s 2>/dev/null`
$as_echo "$as_me: ending at: $at_stop_date" >&5
case $at_start_time,$at_stop_time in
  [0-9]*,[0-9]*)
    as_fn_arith $at_stop_time - $at_start_time && at_duration_s=$as_val
    as_fn_arith $at_duration_s / 60 && at_duration_m=$as_val
    as_fn_arith $at_duration_m / 60 && at_duration_h=$as_val
    as_fn_arith $at_duration_s % 60 && at_duration_s=$as_val
    as_fn_arith $at_duration_m % 60 && at_duration_m=$as_val
    at_duration="${at_duration_h}h ${at_duration_m}m ${at_duration_s}s"
    $as_echo "$as_me: test suite duration: $at_duration" >&5
    ;;
esac

echo
$as_echo "## ------------- ##
## Test results. ##
## ------------- ##"
echo
{
  echo
  $as_echo "## ------------- ##
## Test results. ##
## ------------- ##"
  echo
} >&5

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

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

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

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

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

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

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

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

if test $at_unexpected_count = 0; then
  echo "$at_color$at_result$at_std"
  echo "$at_result" >&5
else
  echo "${at_color}ERROR: $at_result$at_std" >&2
  echo "ERROR: $at_result" >&5
  {
    echo
    $as_echo "## ------------------------ ##
## Summary of the failures. ##
## ------------------------ ##"

    # Summary of failed and skipped tests.
    if test $at_fail_count != 0; then
      echo "Failed tests:"
      $SHELL "$at_myself" $at_fail_list --list
      echo
    fi
    if test $at_skip_count != 0; then
      echo "Skipped tests:"
      $SHELL "$at_myself" $at_skip_list --list
      echo
    fi
    if test $at_xpass_count != 0; then
      echo "Unexpected passes:"
      $SHELL "$at_myself" $at_xpass_list --list
      echo
    fi
    if test $at_fail_count != 0; then
      $as_echo "## ---------------------- ##
## Detailed failed tests. ##
## ---------------------- ##"
      echo
      for at_group in $at_fail_list
      do
	at_group_normalized=$at_group

  eval 'while :; do
    case $at_group_normalized in #(
    '"$at_format"'*) break;;
    esac
    at_group_normalized=0$at_group_normalized
  done'

	cat "$at_suite_dir/$at_group_normalized/$as_me.log"
	echo
      done
      echo
    fi
    if test -n "$at_top_srcdir"; then
      sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## ${at_top_build_prefix}config.log ##
_ASBOX
      sed 's/^/| /' ${at_top_build_prefix}config.log
      echo
    fi
  } >&5

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

  echo
  if $at_debug_p; then
    at_msg='per-test log files'
  else
    at_msg="\`${at_testdir+${at_testdir}/}$as_me.log'"
  fi
  $as_echo "Please send $at_msg and all information you think might help:

   To: <chulbe2lsu@users.sourceforge.net>
   Subject: [MATIO 1.5.0] $as_me: $at_fail_list${at_fail_list:+ failed${at_xpass_list:+, }}$at_xpass_list${at_xpass_list:+ passed unexpectedly}

You may investigate any problem if you feel able to do so, in which
case the test suite provides a good starting point.  Its output may
be found below \`${at_testdir+${at_testdir}/}$as_me.dir'.
"
  exit 1
fi

exit 0

## ------------- ##
## Actual tests. ##
## ------------- ##
#AT_START_1
at_fn_group_banner 1 'mat4_read.at:29' \
  "Read 2d double-precision array" "                 " 1
at_xfail=no
(
  $as_echo "1. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/mat4_read.at:44: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_v4_le.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_le.mat var1" "mat4_read.at:44"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_le.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat4_read.at:44"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_1
#AT_START_2
at_fn_group_banner 2 'mat4_read.at:47' \
  "Read 2d double-precision complex array" "         " 1
at_xfail=no
(
  $as_echo "2. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/mat4_read.at:62: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_v4_le.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_le.mat var11" "mat4_read.at:62"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_le.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat4_read.at:62"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_2
#AT_START_3
at_fn_group_banner 3 'mat4_read.at:65' \
  "Read 2D character array" "                        " 1
at_xfail=no
(
  $as_echo "3. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/mat4_read.at:80: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_v4_le.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_le.mat var24" "mat4_read.at:80"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_le.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat4_read.at:80"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_3
#AT_START_4
at_fn_group_banner 4 'mat4_read_be.at:29' \
  "Read 2d double-precision array" "                 " 2
at_xfail=no
(
  $as_echo "4. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/mat4_read_be.at:44: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_v4_be.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_be.mat var1" "mat4_read_be.at:44"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_be.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat4_read_be.at:44"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_4
#AT_START_5
at_fn_group_banner 5 'mat4_read_be.at:47' \
  "Read 2d double-precision complex array" "         " 2
at_xfail=no
(
  $as_echo "5. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/mat4_read_be.at:62: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_v4_be.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_be.mat var11" "mat4_read_be.at:62"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_be.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat4_read_be.at:62"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_5
#AT_START_6
at_fn_group_banner 6 'mat4_read_be.at:65' \
  "Read 2D character array" "                        " 2
at_xfail=no
(
  $as_echo "6. $at_setup_line: testing $at_desc ..."
  $at_traceon


{ set +x
$as_echo "$at_srcdir/mat4_read_be.at:80: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_v4_be.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_be.mat var24" "mat4_read_be.at:80"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_v4_be.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat4_read_be.at:80"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_6
#AT_START_7
at_fn_group_banner 7 'mat5_uncompressed_read_le.at:27' \
  "Read 2D double-precision array" "                 " 3
at_xfail=no
(
  $as_echo "7. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:41: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var1" "mat5_uncompressed_read_le.at:41"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:41"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_7
#AT_START_8
at_fn_group_banner 8 'mat5_uncompressed_read_le.at:44' \
  "Read 2D single-precision array" "                 " 3
at_xfail=no
(
  $as_echo "8. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:58: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var2" "mat5_uncompressed_read_le.at:58"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var2
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:58"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_8
#AT_START_9
at_fn_group_banner 9 'mat5_uncompressed_read_le.at:61' \
  "Read 2D 64-bit integer array" "                   " 3
at_xfail=no
(
  $as_echo "9. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:75: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var3" "mat5_uncompressed_read_le.at:75"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var3
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:75"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_9
#AT_START_10
at_fn_group_banner 10 'mat5_uncompressed_read_le.at:78' \
  "Read 2D 64-bit unsigned integer array" "          " 3
at_xfail=no
(
  $as_echo "10. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:92: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var4" "mat5_uncompressed_read_le.at:92"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var4
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:92"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_10
#AT_START_11
at_fn_group_banner 11 'mat5_uncompressed_read_le.at:95' \
  "Read 2D 32-bit integer array" "                   " 3
at_xfail=no
(
  $as_echo "11. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:109: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var5"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var5" "mat5_uncompressed_read_le.at:109"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var5
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var5
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:109"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_11
#AT_START_12
at_fn_group_banner 12 'mat5_uncompressed_read_le.at:112' \
  "Read 2D 32-bit unsigned integer array" "          " 3
at_xfail=no
(
  $as_echo "12. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:126: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var6"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var6" "mat5_uncompressed_read_le.at:126"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var6
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var6
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:126"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_12
#AT_START_13
at_fn_group_banner 13 'mat5_uncompressed_read_le.at:129' \
  "Read 2D 16-bit integer array" "                   " 3
at_xfail=no
(
  $as_echo "13. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:143: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var7"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var7" "mat5_uncompressed_read_le.at:143"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var7
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var7
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:143"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_13
#AT_START_14
at_fn_group_banner 14 'mat5_uncompressed_read_le.at:146' \
  "Read 2D 16-bit unsigned integer array" "          " 3
at_xfail=no
(
  $as_echo "14. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:160: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var8"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var8" "mat5_uncompressed_read_le.at:160"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var8
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var8
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:160"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_14
#AT_START_15
at_fn_group_banner 15 'mat5_uncompressed_read_le.at:163' \
  "Read 2D 8-bit integer array" "                    " 3
at_xfail=no
(
  $as_echo "15. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:177: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var9"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var9" "mat5_uncompressed_read_le.at:177"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var9
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var9
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:177"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_15
#AT_START_16
at_fn_group_banner 16 'mat5_uncompressed_read_le.at:180' \
  "Read 2D 8-bit unsigned integer array" "           " 3
at_xfail=no
(
  $as_echo "16. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:194: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var10"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var10" "mat5_uncompressed_read_le.at:194"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var10
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var10
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:194"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_16
#AT_START_17
at_fn_group_banner 17 'mat5_uncompressed_read_le.at:197' \
  "Read 2D double-precision complex array" "         " 3
at_xfail=no
(
  $as_echo "17. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:211: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var11" "mat5_uncompressed_read_le.at:211"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:211"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_17
#AT_START_18
at_fn_group_banner 18 'mat5_uncompressed_read_le.at:214' \
  "Read 2D single-precision complex array" "         " 3
at_xfail=no
(
  $as_echo "18. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:228: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var12"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var12" "mat5_uncompressed_read_le.at:228"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var12
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var12
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:228"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_18
#AT_START_19
at_fn_group_banner 19 'mat5_uncompressed_read_le.at:231' \
  "Read 2D 64-bit integer complex array" "           " 3
at_xfail=no
(
  $as_echo "19. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:245: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var13"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var13" "mat5_uncompressed_read_le.at:245"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var13
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var13
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:245"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_19
#AT_START_20
at_fn_group_banner 20 'mat5_uncompressed_read_le.at:248' \
  "Read 2D 64-bit unsigned integer complex array" "  " 3
at_xfail=no
(
  $as_echo "20. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:262: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var14"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var14" "mat5_uncompressed_read_le.at:262"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var14
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var14
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:262"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_20
#AT_START_21
at_fn_group_banner 21 'mat5_uncompressed_read_le.at:265' \
  "Read 2D 32-bit integer complex array" "           " 3
at_xfail=no
(
  $as_echo "21. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:279: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var15"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var15" "mat5_uncompressed_read_le.at:279"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var15
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var15
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:279"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_21
#AT_START_22
at_fn_group_banner 22 'mat5_uncompressed_read_le.at:282' \
  "Read 2D 32-bit unsigned integer complex array" "  " 3
at_xfail=no
(
  $as_echo "22. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:296: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var16"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var16" "mat5_uncompressed_read_le.at:296"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var16
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var16
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:296"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_22
#AT_START_23
at_fn_group_banner 23 'mat5_uncompressed_read_le.at:299' \
  "Read 2D 16-bit integer complex array" "           " 3
at_xfail=no
(
  $as_echo "23. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:313: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var17"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var17" "mat5_uncompressed_read_le.at:313"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var17
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var17
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:313"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_23
#AT_START_24
at_fn_group_banner 24 'mat5_uncompressed_read_le.at:316' \
  "Read 2D 16-bit unsigned integer complex array" "  " 3
at_xfail=no
(
  $as_echo "24. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:330: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var18"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var18" "mat5_uncompressed_read_le.at:330"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var18
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var18
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:330"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_24
#AT_START_25
at_fn_group_banner 25 'mat5_uncompressed_read_le.at:333' \
  "Read 2D 8-bit integer complex array" "            " 3
at_xfail=no
(
  $as_echo "25. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:347: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var19"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var19" "mat5_uncompressed_read_le.at:347"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var19
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var19
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:347"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_25
#AT_START_26
at_fn_group_banner 26 'mat5_uncompressed_read_le.at:350' \
  "Read 2D 8-bit unsigned integer complex array" "   " 3
at_xfail=no
(
  $as_echo "26. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:364: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var20"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var20" "mat5_uncompressed_read_le.at:364"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var20
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var20
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:364"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_26
#AT_START_27
at_fn_group_banner 27 'mat5_uncompressed_read_le.at:367' \
  "Read double-precision sparse array" "             " 3
at_xfail=no
(
  $as_echo "27. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:382: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var21"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var21" "mat5_uncompressed_read_le.at:382"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var21
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var21
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,2)  2
    (3,3)  3
    (4,4)  4
    (5,5)  5
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:382"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_27
#AT_START_28
at_fn_group_banner 28 'mat5_uncompressed_read_le.at:385' \
  "Read double-precision sparse complex array" "     " 3
at_xfail=no
(
  $as_echo "28. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:400: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var22"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var22" "mat5_uncompressed_read_le.at:400"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var22
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var22
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 6i
    (2,2)  2 + 7i
    (3,3)  3 + 8i
    (4,4)  4 + 9i
    (5,5)  5 + 10i
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:400"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_28
#AT_START_29
at_fn_group_banner 29 'mat5_uncompressed_read_le.at:403' \
  "Read empty array" "                               " 3
at_xfail=no
(
  $as_echo "29. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:410: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var23"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var23" "mat5_uncompressed_read_le.at:410"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var23
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var23
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:410"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_29
#AT_START_30
at_fn_group_banner 30 'mat5_uncompressed_read_le.at:413' \
  "Read 2D character array" "                        " 3
at_xfail=no
(
  $as_echo "30. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:427: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var24" "mat5_uncompressed_read_le.at:427"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:427"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_30
#AT_START_31
at_fn_group_banner 31 'mat5_uncompressed_read_le.at:430' \
  "Read empty structure array" "                     " 3
at_xfail=no
(
  $as_echo "31. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:440: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var25"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var25" "mat5_uncompressed_read_le.at:440"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var25
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var25
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:440"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_31
#AT_START_32
at_fn_group_banner 32 'mat5_uncompressed_read_le.at:443' \
  "Read empty structure array with fields" "         " 3
at_xfail=no
(
  $as_echo "32. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:457: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var26"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var26" "mat5_uncompressed_read_le.at:457"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var26
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var26
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:457"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_32
#AT_START_33
at_fn_group_banner 33 'mat5_uncompressed_read_le.at:460' \
  "Read structure array with empty fields" "         " 3
at_xfail=no
(
  $as_echo "33. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:492: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var27"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var27" "mat5_uncompressed_read_le.at:492"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var27
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var27
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:492"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_33
#AT_START_34
at_fn_group_banner 34 'mat5_uncompressed_read_le.at:495' \
  "Read structure array with double-precision fields" "" 3
at_xfail=no
(
  $as_echo "34. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:541: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var28"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var28" "mat5_uncompressed_read_le.at:541"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var28
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var28
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:541"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_34
#AT_START_35
at_fn_group_banner 35 'mat5_uncompressed_read_le.at:544' \
  "Read structure array with single-precision fields" "" 3
at_xfail=no
(
  $as_echo "35. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:590: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var29"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var29" "mat5_uncompressed_read_le.at:590"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var29
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var29
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:590"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_35
#AT_START_36
at_fn_group_banner 36 'mat5_uncompressed_read_le.at:593' \
  "Read structure array with 64-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "36. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:639: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var30"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var30" "mat5_uncompressed_read_le.at:639"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var30
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var30
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:639"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_36
#AT_START_37
at_fn_group_banner 37 'mat5_uncompressed_read_le.at:642' \
  "Read structure array with 64-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "37. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:688: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var31"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var31" "mat5_uncompressed_read_le.at:688"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var31
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var31
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:688"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_37
#AT_START_38
at_fn_group_banner 38 'mat5_uncompressed_read_le.at:691' \
  "Read structure array with 32-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "38. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:737: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var32"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var32" "mat5_uncompressed_read_le.at:737"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var32
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var32
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:737"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_38
#AT_START_39
at_fn_group_banner 39 'mat5_uncompressed_read_le.at:740' \
  "Read structure array with 32-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "39. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:786: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var33"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var33" "mat5_uncompressed_read_le.at:786"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var33
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var33
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:786"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_39
#AT_START_40
at_fn_group_banner 40 'mat5_uncompressed_read_le.at:789' \
  "Read structure array with 16-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "40. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:835: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var34"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var34" "mat5_uncompressed_read_le.at:835"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var34
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var34
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:835"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_40
#AT_START_41
at_fn_group_banner 41 'mat5_uncompressed_read_le.at:838' \
  "Read structure array with 16-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "41. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:884: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var35"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var35" "mat5_uncompressed_read_le.at:884"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var35
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var35
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:884"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_41
#AT_START_42
at_fn_group_banner 42 'mat5_uncompressed_read_le.at:887' \
  "Read structure array with 8-bit integer fields" " " 3
at_xfail=no
(
  $as_echo "42. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:933: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var36"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var36" "mat5_uncompressed_read_le.at:933"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var36
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var36
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:933"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_42
#AT_START_43
at_fn_group_banner 43 'mat5_uncompressed_read_le.at:936' \
  "Read structure array with 8-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "43. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:982: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var37"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var37" "mat5_uncompressed_read_le.at:982"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var37
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var37
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:982"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_43
#AT_START_44
at_fn_group_banner 44 'mat5_uncompressed_read_le.at:985' \
  "Read structure array with complex double-precision fields" "" 3
at_xfail=no
(
  $as_echo "44. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1031: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var38"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var38" "mat5_uncompressed_read_le.at:1031"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var38
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var38
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1031"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_44
#AT_START_45
at_fn_group_banner 45 'mat5_uncompressed_read_le.at:1034' \
  "Read structure array with complex single-precision fields" "" 3
at_xfail=no
(
  $as_echo "45. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1080: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var39"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var39" "mat5_uncompressed_read_le.at:1080"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var39
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var39
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1080"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_45
#AT_START_46
at_fn_group_banner 46 'mat5_uncompressed_read_le.at:1083' \
  "Read structure array with complex 64-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "46. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1129: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var40"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var40" "mat5_uncompressed_read_le.at:1129"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var40
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var40
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1129"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_46
#AT_START_47
at_fn_group_banner 47 'mat5_uncompressed_read_le.at:1132' \
  "Read structure array with complex 64-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "47. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1178: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var41"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var41" "mat5_uncompressed_read_le.at:1178"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var41
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var41
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1178"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_47
#AT_START_48
at_fn_group_banner 48 'mat5_uncompressed_read_le.at:1181' \
  "Read structure array with complex 32-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "48. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1227: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var42"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var42" "mat5_uncompressed_read_le.at:1227"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var42
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var42
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1227"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_48
#AT_START_49
at_fn_group_banner 49 'mat5_uncompressed_read_le.at:1230' \
  "Read structure array with complex 32-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "49. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1276: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var43"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var43" "mat5_uncompressed_read_le.at:1276"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var43
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var43
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1276"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_49
#AT_START_50
at_fn_group_banner 50 'mat5_uncompressed_read_le.at:1279' \
  "Read structure array with complex 16-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "50. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1325: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var44"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var44" "mat5_uncompressed_read_le.at:1325"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var44
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var44
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1325"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_50
#AT_START_51
at_fn_group_banner 51 'mat5_uncompressed_read_le.at:1328' \
  "Read structure array with complex 16-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "51. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1374: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var45"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var45" "mat5_uncompressed_read_le.at:1374"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var45
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var45
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1374"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_51
#AT_START_52
at_fn_group_banner 52 'mat5_uncompressed_read_le.at:1377' \
  "Read structure array with complex 8-bit integer fields" "" 3
at_xfail=no
(
  $as_echo "52. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1423: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var46"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var46" "mat5_uncompressed_read_le.at:1423"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var46
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var46
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1423"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_52
#AT_START_53
at_fn_group_banner 53 'mat5_uncompressed_read_le.at:1426' \
  "Read structure array with complex 8-bit unsigned integer fields" "" 3
at_xfail=no
(
  $as_echo "53. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1472: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var47"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var47" "mat5_uncompressed_read_le.at:1472"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var47
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var47
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1472"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_53
#AT_START_54
at_fn_group_banner 54 'mat5_uncompressed_read_le.at:1475' \
  "Read structure array with double-precision sparse fields" "" 3
at_xfail=no
(
  $as_echo "54. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1527: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var48"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var48" "mat5_uncompressed_read_le.at:1527"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var48
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var48
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1527"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_54
#AT_START_55
at_fn_group_banner 55 'mat5_uncompressed_read_le.at:1530' \
  "Read structure array with complex double-precision sparse fields" "" 3
at_xfail=no
(
  $as_echo "55. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1582: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var49"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var49" "mat5_uncompressed_read_le.at:1582"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var49
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var49
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1582"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_55
#AT_START_56
at_fn_group_banner 56 'mat5_uncompressed_read_le.at:1585' \
  "Read structure array with character fields" "     " 3
at_xfail=no
(
  $as_echo "56. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1627: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var50"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var50" "mat5_uncompressed_read_le.at:1627"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var50
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var50
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1627"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_56
#AT_START_57
at_fn_group_banner 57 'mat5_uncompressed_read_le.at:1630' \
  "Read empty cell array" "                          " 3
at_xfail=no
(
  $as_echo "57. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1640: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var51"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var51" "mat5_uncompressed_read_le.at:1640"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var51
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var51
      Rank: 2
Dimensions: 0 x 0
Class Type: Cell Array
 Data Type: Cell Array
{
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1640"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_57
#AT_START_58
at_fn_group_banner 58 'mat5_uncompressed_read_le.at:1643' \
  "Read cell array with empty arrays" "              " 3
at_xfail=no
(
  $as_echo "58. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1683: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var52"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var52" "mat5_uncompressed_read_le.at:1683"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var52
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var52
      Rank: 2
Dimensions: 1 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: Single Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, unsigned integer array
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1683"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_58
#AT_START_59
at_fn_group_banner 59 'mat5_uncompressed_read_le.at:1686' \
  "Read cell array with double-precision arrays" "   " 3
at_xfail=no
(
  $as_echo "59. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1747: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var53"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var53" "mat5_uncompressed_read_le.at:1747"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var53
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var53
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1747"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_59
#AT_START_60
at_fn_group_banner 60 'mat5_uncompressed_read_le.at:1750' \
  "Read cell array with single-precision arrays" "   " 3
at_xfail=no
(
  $as_echo "60. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1811: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var54"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var54" "mat5_uncompressed_read_le.at:1811"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var54
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var54
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1811"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_60
#AT_START_61
at_fn_group_banner 61 'mat5_uncompressed_read_le.at:1814' \
  "Read cell array with 64-bit integer arrays" "     " 3
at_xfail=no
(
  $as_echo "61. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1875: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var55"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var55" "mat5_uncompressed_read_le.at:1875"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var55
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var55
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1875"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_61
#AT_START_62
at_fn_group_banner 62 'mat5_uncompressed_read_le.at:1878' \
  "Read cell array with 64-bit unsigned integer arrays" "" 3
at_xfail=no
(
  $as_echo "62. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:1939: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var56"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var56" "mat5_uncompressed_read_le.at:1939"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var56
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var56
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:1939"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_62
#AT_START_63
at_fn_group_banner 63 'mat5_uncompressed_read_le.at:1942' \
  "Read cell array with 32-bit integer arrays" "     " 3
at_xfail=no
(
  $as_echo "63. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2003: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var57"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var57" "mat5_uncompressed_read_le.at:2003"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var57
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var57
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2003"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_63
#AT_START_64
at_fn_group_banner 64 'mat5_uncompressed_read_le.at:2006' \
  "Read cell array with 32-bit unsigned integer arrays" "" 3
at_xfail=no
(
  $as_echo "64. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2067: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var58"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var58" "mat5_uncompressed_read_le.at:2067"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var58
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var58
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2067"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_64
#AT_START_65
at_fn_group_banner 65 'mat5_uncompressed_read_le.at:2070' \
  "Read cell array with 16-bit integer arrays" "     " 3
at_xfail=no
(
  $as_echo "65. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2131: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var59"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var59" "mat5_uncompressed_read_le.at:2131"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var59
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var59
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2131"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_65
#AT_START_66
at_fn_group_banner 66 'mat5_uncompressed_read_le.at:2134' \
  "Read cell array with 16-bit unsigned integer arrays" "" 3
at_xfail=no
(
  $as_echo "66. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2195: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var60"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var60" "mat5_uncompressed_read_le.at:2195"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var60
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var60
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2195"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_66
#AT_START_67
at_fn_group_banner 67 'mat5_uncompressed_read_le.at:2198' \
  "Read cell array with 8-bit integer arrays" "      " 3
at_xfail=no
(
  $as_echo "67. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2259: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var61"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var61" "mat5_uncompressed_read_le.at:2259"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var61
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var61
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2259"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_67
#AT_START_68
at_fn_group_banner 68 'mat5_uncompressed_read_le.at:2262' \
  "Read cell array with 8-bit unsigned integer arrays" "" 3
at_xfail=no
(
  $as_echo "68. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2323: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var62"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var62" "mat5_uncompressed_read_le.at:2323"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var62
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var62
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2323"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_68
#AT_START_69
at_fn_group_banner 69 'mat5_uncompressed_read_le.at:2326' \
  "Read cell array with double-precision sparse arrays" "" 3
at_xfail=no
(
  $as_echo "69. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2376: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var63"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var63" "mat5_uncompressed_read_le.at:2376"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var63
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var63
      Rank: 2
Dimensions: 1 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2376"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_69
#AT_START_70
at_fn_group_banner 70 'mat5_uncompressed_read_le.at:2379' \
  "Read cell array with complex double-precision sparse arrays" "" 3
at_xfail=no
(
  $as_echo "70. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2429: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var64"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var64" "mat5_uncompressed_read_le.at:2429"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var64
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var64
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2429"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_70
#AT_START_71
at_fn_group_banner 71 'mat5_uncompressed_read_le.at:2432' \
  "Read cell array with character arrays" "          " 3
at_xfail=no
(
  $as_echo "71. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2470: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var65"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var65" "mat5_uncompressed_read_le.at:2470"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var65
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var65
      Rank: 2
Dimensions: 2 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2470"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_71
#AT_START_72
at_fn_group_banner 72 'mat5_uncompressed_read_le.at:2473' \
  "Read cell array with empty structure arrays" "    " 3
at_xfail=no
(
  $as_echo "72. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:2527: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var66"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var66" "mat5_uncompressed_read_le.at:2527"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var66
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var66
      Rank: 2
Dimensions: 1 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:2527"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_72
#AT_START_73
at_fn_group_banner 73 'mat5_uncompressed_read_le.at:2530' \
  "Read cell array with structure arrays (numeric fields)" "" 3
at_xfail=no
(
  $as_echo "73. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:3380: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var67"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var67" "mat5_uncompressed_read_le.at:3380"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var67
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var67
      Rank: 2
Dimensions: 2 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:3380"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_73
#AT_START_74
at_fn_group_banner 74 'mat5_uncompressed_read_le.at:3383' \
  "Read cell array with structure arrays (sparse fields)" "" 3
at_xfail=no
(
  $as_echo "74. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:3489: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var68"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var68" "mat5_uncompressed_read_le.at:3489"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var68
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var68
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:3489"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_74
#AT_START_75
at_fn_group_banner 75 'mat5_uncompressed_read_le.at:3492' \
  "Read cell array structure arrays (character fields)" "" 3
at_xfail=no
(
  $as_echo "75. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_le.at:3546: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_le.mat var69"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var69" "mat5_uncompressed_read_le.at:3546"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_le.mat var69
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var69
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_le.at:3546"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_75
#AT_START_76
at_fn_group_banner 76 'mat5_compressed_read_le.at:27' \
  "Read 2D double-precision array" "                 " 4
at_xfail=no
(
  $as_echo "76. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:28" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:28"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:42: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var1" "mat5_compressed_read_le.at:42"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:42"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_76
#AT_START_77
at_fn_group_banner 77 'mat5_compressed_read_le.at:45' \
  "Read 2D single-precision array" "                 " 4
at_xfail=no
(
  $as_echo "77. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:46" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:46"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:60: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var2" "mat5_compressed_read_le.at:60"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var2
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:60"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_77
#AT_START_78
at_fn_group_banner 78 'mat5_compressed_read_le.at:63' \
  "Read 2D 64-bit integer array" "                   " 4
at_xfail=no
(
  $as_echo "78. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:64" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:64"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:78: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var3" "mat5_compressed_read_le.at:78"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var3
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:78"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_78
#AT_START_79
at_fn_group_banner 79 'mat5_compressed_read_le.at:81' \
  "Read 2D 64-bit unsigned integer array" "          " 4
at_xfail=no
(
  $as_echo "79. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:82" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:82"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:96: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var4" "mat5_compressed_read_le.at:96"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var4
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:96"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_79
#AT_START_80
at_fn_group_banner 80 'mat5_compressed_read_le.at:99' \
  "Read 2D 32-bit integer array" "                   " 4
at_xfail=no
(
  $as_echo "80. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:100" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:100"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:114: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var5"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var5" "mat5_compressed_read_le.at:114"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var5
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var5
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:114"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_80
#AT_START_81
at_fn_group_banner 81 'mat5_compressed_read_le.at:117' \
  "Read 2D 32-bit unsigned integer array" "          " 4
at_xfail=no
(
  $as_echo "81. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:118" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:118"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:132: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var6"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var6" "mat5_compressed_read_le.at:132"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var6
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var6
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:132"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_81
#AT_START_82
at_fn_group_banner 82 'mat5_compressed_read_le.at:135' \
  "Read 2D 16-bit integer array" "                   " 4
at_xfail=no
(
  $as_echo "82. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:136" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:136"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:150: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var7"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var7" "mat5_compressed_read_le.at:150"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var7
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var7
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:150"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_82
#AT_START_83
at_fn_group_banner 83 'mat5_compressed_read_le.at:153' \
  "Read 2D 16-bit unsigned integer array" "          " 4
at_xfail=no
(
  $as_echo "83. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:154" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:154"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:168: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var8"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var8" "mat5_compressed_read_le.at:168"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var8
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var8
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:168"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_83
#AT_START_84
at_fn_group_banner 84 'mat5_compressed_read_le.at:171' \
  "Read 2D 8-bit integer array" "                    " 4
at_xfail=no
(
  $as_echo "84. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:172" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:172"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:186: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var9"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var9" "mat5_compressed_read_le.at:186"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var9
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var9
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:186"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_84
#AT_START_85
at_fn_group_banner 85 'mat5_compressed_read_le.at:189' \
  "Read 2D 8-bit unsigned integer array" "           " 4
at_xfail=no
(
  $as_echo "85. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:190" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:190"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:204: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var10"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var10" "mat5_compressed_read_le.at:204"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var10
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var10
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:204"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_85
#AT_START_86
at_fn_group_banner 86 'mat5_compressed_read_le.at:207' \
  "Read 2D double-precision complex array" "         " 4
at_xfail=no
(
  $as_echo "86. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:208" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:208"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:222: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var11" "mat5_compressed_read_le.at:222"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:222"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_86
#AT_START_87
at_fn_group_banner 87 'mat5_compressed_read_le.at:225' \
  "Read 2D single-precision complex array" "         " 4
at_xfail=no
(
  $as_echo "87. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:226" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:226"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:240: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var12"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var12" "mat5_compressed_read_le.at:240"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var12
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var12
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:240"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_87
#AT_START_88
at_fn_group_banner 88 'mat5_compressed_read_le.at:243' \
  "Read 2D 64-bit integer complex array" "           " 4
at_xfail=no
(
  $as_echo "88. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:244" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:244"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:258: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var13"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var13" "mat5_compressed_read_le.at:258"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var13
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var13
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:258"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_88
#AT_START_89
at_fn_group_banner 89 'mat5_compressed_read_le.at:261' \
  "Read 2D 64-bit unsigned integer complex array" "  " 4
at_xfail=no
(
  $as_echo "89. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:262" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:262"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:276: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var14"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var14" "mat5_compressed_read_le.at:276"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var14
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var14
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:276"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_89
#AT_START_90
at_fn_group_banner 90 'mat5_compressed_read_le.at:279' \
  "Read 2D 32-bit integer complex array" "           " 4
at_xfail=no
(
  $as_echo "90. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:280" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:280"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:294: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var15"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var15" "mat5_compressed_read_le.at:294"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var15
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var15
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:294"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_90
#AT_START_91
at_fn_group_banner 91 'mat5_compressed_read_le.at:297' \
  "Read 2D 32-bit unsigned integer complex array" "  " 4
at_xfail=no
(
  $as_echo "91. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:298" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:298"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:312: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var16"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var16" "mat5_compressed_read_le.at:312"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var16
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var16
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:312"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_91
#AT_START_92
at_fn_group_banner 92 'mat5_compressed_read_le.at:315' \
  "Read 2D 16-bit integer complex array" "           " 4
at_xfail=no
(
  $as_echo "92. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:316" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:316"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:330: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var17"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var17" "mat5_compressed_read_le.at:330"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var17
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var17
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:330"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_92
#AT_START_93
at_fn_group_banner 93 'mat5_compressed_read_le.at:333' \
  "Read 2D 16-bit unsigned integer complex array" "  " 4
at_xfail=no
(
  $as_echo "93. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:334" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:334"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:348: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var18"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var18" "mat5_compressed_read_le.at:348"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var18
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var18
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:348"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_93
#AT_START_94
at_fn_group_banner 94 'mat5_compressed_read_le.at:351' \
  "Read 2D 8-bit integer complex array" "            " 4
at_xfail=no
(
  $as_echo "94. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:352" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:352"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:366: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var19"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var19" "mat5_compressed_read_le.at:366"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var19
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var19
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:366"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_94
#AT_START_95
at_fn_group_banner 95 'mat5_compressed_read_le.at:369' \
  "Read 2D 8-bit unsigned integer complex array" "   " 4
at_xfail=no
(
  $as_echo "95. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:370" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:370"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:384: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var20"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var20" "mat5_compressed_read_le.at:384"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var20
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var20
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:384"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_95
#AT_START_96
at_fn_group_banner 96 'mat5_compressed_read_le.at:387' \
  "Read double-precision sparse array" "             " 4
at_xfail=no
(
  $as_echo "96. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:388" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:388"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:403: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var21"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var21" "mat5_compressed_read_le.at:403"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var21
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var21
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,2)  2
    (3,3)  3
    (4,4)  4
    (5,5)  5
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:403"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_96
#AT_START_97
at_fn_group_banner 97 'mat5_compressed_read_le.at:406' \
  "Read double-precision sparse complex array" "     " 4
at_xfail=no
(
  $as_echo "97. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:407" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:407"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:422: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var22"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var22" "mat5_compressed_read_le.at:422"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var22
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var22
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 6i
    (2,2)  2 + 7i
    (3,3)  3 + 8i
    (4,4)  4 + 9i
    (5,5)  5 + 10i
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_97
#AT_START_98
at_fn_group_banner 98 'mat5_compressed_read_le.at:425' \
  "Read empty array" "                               " 4
at_xfail=no
(
  $as_echo "98. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:426" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:426"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:433: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var23"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var23" "mat5_compressed_read_le.at:433"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var23
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var23
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:433"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_98
#AT_START_99
at_fn_group_banner 99 'mat5_compressed_read_le.at:436' \
  "Read 2D character array" "                        " 4
at_xfail=no
(
  $as_echo "99. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:437" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:437"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:451: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var24" "mat5_compressed_read_le.at:451"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:451"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_99
#AT_START_100
at_fn_group_banner 100 'mat5_compressed_read_le.at:454' \
  "Read empty structure array" "                     " 4
at_xfail=no
(
  $as_echo "100. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:455" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:455"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:465: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var25"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var25" "mat5_compressed_read_le.at:465"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var25
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var25
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:465"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_100
#AT_START_101
at_fn_group_banner 101 'mat5_compressed_read_le.at:468' \
  "Read empty structure array with fields" "         " 4
at_xfail=no
(
  $as_echo "101. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:469" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:469"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:483: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var26"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var26" "mat5_compressed_read_le.at:483"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var26
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var26
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:483"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_101
#AT_START_102
at_fn_group_banner 102 'mat5_compressed_read_le.at:486' \
  "Read structure array with empty fields" "         " 4
at_xfail=no
(
  $as_echo "102. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:487" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:487"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:519: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var27"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var27" "mat5_compressed_read_le.at:519"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var27
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var27
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:519"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_102
#AT_START_103
at_fn_group_banner 103 'mat5_compressed_read_le.at:522' \
  "Read structure array with double-precision fields" "" 4
at_xfail=no
(
  $as_echo "103. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:523" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:523"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:569: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var28"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var28" "mat5_compressed_read_le.at:569"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var28
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var28
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:569"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_103
#AT_START_104
at_fn_group_banner 104 'mat5_compressed_read_le.at:572' \
  "Read structure array with single-precision fields" "" 4
at_xfail=no
(
  $as_echo "104. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:573" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:573"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:619: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var29"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var29" "mat5_compressed_read_le.at:619"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var29
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var29
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:619"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_104
#AT_START_105
at_fn_group_banner 105 'mat5_compressed_read_le.at:622' \
  "Read structure array with 64-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "105. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:623" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:623"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:669: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var30"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var30" "mat5_compressed_read_le.at:669"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var30
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var30
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:669"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_105
#AT_START_106
at_fn_group_banner 106 'mat5_compressed_read_le.at:672' \
  "Read structure array with 64-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "106. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:673" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:673"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:719: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var31"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var31" "mat5_compressed_read_le.at:719"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var31
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var31
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:719"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_106
#AT_START_107
at_fn_group_banner 107 'mat5_compressed_read_le.at:722' \
  "Read structure array with 32-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "107. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:723" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:723"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:769: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var32"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var32" "mat5_compressed_read_le.at:769"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var32
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var32
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:769"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_107
#AT_START_108
at_fn_group_banner 108 'mat5_compressed_read_le.at:772' \
  "Read structure array with 32-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "108. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:773" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:773"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:819: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var33"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var33" "mat5_compressed_read_le.at:819"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var33
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var33
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:819"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_108
#AT_START_109
at_fn_group_banner 109 'mat5_compressed_read_le.at:822' \
  "Read structure array with 16-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "109. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:823" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:823"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:869: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var34"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var34" "mat5_compressed_read_le.at:869"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var34
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var34
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:869"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_109
#AT_START_110
at_fn_group_banner 110 'mat5_compressed_read_le.at:872' \
  "Read structure array with 16-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "110. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:873" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:873"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:919: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var35"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var35" "mat5_compressed_read_le.at:919"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var35
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var35
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:919"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_110
#AT_START_111
at_fn_group_banner 111 'mat5_compressed_read_le.at:922' \
  "Read structure array with 8-bit integer fields" " " 4
at_xfail=no
(
  $as_echo "111. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:923" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:923"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:969: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var36"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var36" "mat5_compressed_read_le.at:969"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var36
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var36
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:969"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_111
#AT_START_112
at_fn_group_banner 112 'mat5_compressed_read_le.at:972' \
  "Read structure array with 8-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "112. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:973" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:973"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1019: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var37"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var37" "mat5_compressed_read_le.at:1019"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var37
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var37
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1019"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_112
#AT_START_113
at_fn_group_banner 113 'mat5_compressed_read_le.at:1022' \
  "Read structure array with complex double-precision fields" "" 4
at_xfail=no
(
  $as_echo "113. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1023" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1023"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1069: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var38"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var38" "mat5_compressed_read_le.at:1069"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var38
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var38
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1069"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_113
#AT_START_114
at_fn_group_banner 114 'mat5_compressed_read_le.at:1072' \
  "Read structure array with complex single-precision fields" "" 4
at_xfail=no
(
  $as_echo "114. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1073" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1073"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1119: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var39"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var39" "mat5_compressed_read_le.at:1119"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var39
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var39
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1119"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_114
#AT_START_115
at_fn_group_banner 115 'mat5_compressed_read_le.at:1122' \
  "Read structure array with complex 64-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "115. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1123" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1123"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1169: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var40"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var40" "mat5_compressed_read_le.at:1169"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var40
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var40
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1169"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_115
#AT_START_116
at_fn_group_banner 116 'mat5_compressed_read_le.at:1172' \
  "Read structure array with complex 64-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "116. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1173" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1173"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1219: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var41"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var41" "mat5_compressed_read_le.at:1219"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var41
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var41
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1219"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_116
#AT_START_117
at_fn_group_banner 117 'mat5_compressed_read_le.at:1222' \
  "Read structure array with complex 32-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "117. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1223" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1223"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1269: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var42"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var42" "mat5_compressed_read_le.at:1269"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var42
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var42
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1269"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_117
#AT_START_118
at_fn_group_banner 118 'mat5_compressed_read_le.at:1272' \
  "Read structure array with complex 32-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "118. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1273" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1273"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1319: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var43"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var43" "mat5_compressed_read_le.at:1319"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var43
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var43
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1319"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_118
#AT_START_119
at_fn_group_banner 119 'mat5_compressed_read_le.at:1322' \
  "Read structure array with complex 16-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "119. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1323" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1323"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1369: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var44"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var44" "mat5_compressed_read_le.at:1369"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var44
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var44
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1369"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_119
#AT_START_120
at_fn_group_banner 120 'mat5_compressed_read_le.at:1372' \
  "Read structure array with complex 16-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "120. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1373" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1373"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1419: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var45"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var45" "mat5_compressed_read_le.at:1419"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var45
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var45
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1419"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_120
#AT_START_121
at_fn_group_banner 121 'mat5_compressed_read_le.at:1422' \
  "Read structure array with complex 8-bit integer fields" "" 4
at_xfail=no
(
  $as_echo "121. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1423" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1423"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1469: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var46"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var46" "mat5_compressed_read_le.at:1469"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var46
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var46
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1469"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_121
#AT_START_122
at_fn_group_banner 122 'mat5_compressed_read_le.at:1472' \
  "Read structure array with complex 8-bit unsigned integer fields" "" 4
at_xfail=no
(
  $as_echo "122. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1473" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1473"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1519: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var47"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var47" "mat5_compressed_read_le.at:1519"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var47
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var47
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1519"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_122
#AT_START_123
at_fn_group_banner 123 'mat5_compressed_read_le.at:1522' \
  "Read structure array with double-precision sparse fields" "" 4
at_xfail=no
(
  $as_echo "123. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1523" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1523"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1575: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var48"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var48" "mat5_compressed_read_le.at:1575"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var48
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var48
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1575"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_123
#AT_START_124
at_fn_group_banner 124 'mat5_compressed_read_le.at:1578' \
  "Read structure array with complex double-precision sparse fields" "" 4
at_xfail=no
(
  $as_echo "124. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1579" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1579"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1631: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var49"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var49" "mat5_compressed_read_le.at:1631"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var49
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var49
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1631"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_124
#AT_START_125
at_fn_group_banner 125 'mat5_compressed_read_le.at:1634' \
  "Read structure array with character fields" "     " 4
at_xfail=no
(
  $as_echo "125. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1635" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1635"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1677: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var50"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var50" "mat5_compressed_read_le.at:1677"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var50
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var50
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1677"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_125
#AT_START_126
at_fn_group_banner 126 'mat5_compressed_read_le.at:1680' \
  "Read empty cell array" "                          " 4
at_xfail=no
(
  $as_echo "126. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1681" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1681"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1691: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var51"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var51" "mat5_compressed_read_le.at:1691"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var51
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var51
      Rank: 2
Dimensions: 0 x 0
Class Type: Cell Array
 Data Type: Cell Array
{
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1691"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_126
#AT_START_127
at_fn_group_banner 127 'mat5_compressed_read_le.at:1694' \
  "Read cell array with empty arrays" "              " 4
at_xfail=no
(
  $as_echo "127. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1695" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1695"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1735: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var52"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var52" "mat5_compressed_read_le.at:1735"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var52
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var52
      Rank: 2
Dimensions: 1 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: Single Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, unsigned integer array
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1735"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_127
#AT_START_128
at_fn_group_banner 128 'mat5_compressed_read_le.at:1738' \
  "Read cell array with double-precision arrays" "   " 4
at_xfail=no
(
  $as_echo "128. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1739" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1739"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1800: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var53"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var53" "mat5_compressed_read_le.at:1800"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var53
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var53
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1800"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_128
#AT_START_129
at_fn_group_banner 129 'mat5_compressed_read_le.at:1803' \
  "Read cell array with single-precision arrays" "   " 4
at_xfail=no
(
  $as_echo "129. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1804" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1804"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1865: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var54"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var54" "mat5_compressed_read_le.at:1865"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var54
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var54
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1865"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_129
#AT_START_130
at_fn_group_banner 130 'mat5_compressed_read_le.at:1868' \
  "Read cell array with 64-bit integer arrays" "     " 4
at_xfail=no
(
  $as_echo "130. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1869" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1869"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1930: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var55"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var55" "mat5_compressed_read_le.at:1930"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var55
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var55
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1930"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_130
#AT_START_131
at_fn_group_banner 131 'mat5_compressed_read_le.at:1933' \
  "Read cell array with 64-bit unsigned integer arrays" "" 4
at_xfail=no
(
  $as_echo "131. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1934" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1934"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:1995: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var56"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var56" "mat5_compressed_read_le.at:1995"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var56
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var56
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:1995"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_131
#AT_START_132
at_fn_group_banner 132 'mat5_compressed_read_le.at:1998' \
  "Read cell array with 32-bit integer arrays" "     " 4
at_xfail=no
(
  $as_echo "132. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:1999" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:1999"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2060: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var57"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var57" "mat5_compressed_read_le.at:2060"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var57
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var57
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2060"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_132
#AT_START_133
at_fn_group_banner 133 'mat5_compressed_read_le.at:2063' \
  "Read cell array with 32-bit unsigned integer arrays" "" 4
at_xfail=no
(
  $as_echo "133. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2064" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2064"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2125: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var58"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var58" "mat5_compressed_read_le.at:2125"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var58
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var58
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2125"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_133
#AT_START_134
at_fn_group_banner 134 'mat5_compressed_read_le.at:2128' \
  "Read cell array with 16-bit integer arrays" "     " 4
at_xfail=no
(
  $as_echo "134. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2129" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2129"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2190: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var59"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var59" "mat5_compressed_read_le.at:2190"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var59
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var59
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2190"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_134
#AT_START_135
at_fn_group_banner 135 'mat5_compressed_read_le.at:2193' \
  "Read cell array with 16-bit unsigned integer arrays" "" 4
at_xfail=no
(
  $as_echo "135. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2194" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2194"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2255: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var60"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var60" "mat5_compressed_read_le.at:2255"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var60
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var60
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2255"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_135
#AT_START_136
at_fn_group_banner 136 'mat5_compressed_read_le.at:2258' \
  "Read cell array with 8-bit integer arrays" "      " 4
at_xfail=no
(
  $as_echo "136. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2259" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2259"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2320: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var61"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var61" "mat5_compressed_read_le.at:2320"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var61
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var61
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2320"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_136
#AT_START_137
at_fn_group_banner 137 'mat5_compressed_read_le.at:2323' \
  "Read cell array with 8-bit unsigned integer arrays" "" 4
at_xfail=no
(
  $as_echo "137. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2324" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2324"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2385: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var62"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var62" "mat5_compressed_read_le.at:2385"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var62
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var62
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2385"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_137
#AT_START_138
at_fn_group_banner 138 'mat5_compressed_read_le.at:2388' \
  "Read cell array with double-precision sparse arrays" "" 4
at_xfail=no
(
  $as_echo "138. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2389" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2389"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2439: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var63"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var63" "mat5_compressed_read_le.at:2439"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var63
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var63
      Rank: 2
Dimensions: 1 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2439"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_138
#AT_START_139
at_fn_group_banner 139 'mat5_compressed_read_le.at:2442' \
  "Read cell array with complex double-precision sparse arrays" "" 4
at_xfail=no
(
  $as_echo "139. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2443" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2443"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2493: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var64"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var64" "mat5_compressed_read_le.at:2493"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var64
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var64
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2493"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_139
#AT_START_140
at_fn_group_banner 140 'mat5_compressed_read_le.at:2496' \
  "Read cell array with character arrays" "          " 4
at_xfail=no
(
  $as_echo "140. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2497" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2497"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2535: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var65"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var65" "mat5_compressed_read_le.at:2535"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var65
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var65
      Rank: 2
Dimensions: 2 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2535"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_140
#AT_START_141
at_fn_group_banner 141 'mat5_compressed_read_le.at:2538' \
  "Read cell array with empty structure arrays" "    " 4
at_xfail=no
(
  $as_echo "141. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2539" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2539"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:2593: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var66"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var66" "mat5_compressed_read_le.at:2593"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var66
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var66
      Rank: 2
Dimensions: 1 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:2593"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_141
#AT_START_142
at_fn_group_banner 142 'mat5_compressed_read_le.at:2596' \
  "Read cell array with structure arrays (numeric fields)" "" 4
at_xfail=no
(
  $as_echo "142. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:2597" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:2597"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:3447: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var67"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var67" "mat5_compressed_read_le.at:3447"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var67
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var67
      Rank: 2
Dimensions: 2 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:3447"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_142
#AT_START_143
at_fn_group_banner 143 'mat5_compressed_read_le.at:3450' \
  "Read cell array with structure arrays (sparse fields)" "" 4
at_xfail=no
(
  $as_echo "143. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:3451" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:3451"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:3557: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var68"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var68" "mat5_compressed_read_le.at:3557"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var68
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var68
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:3557"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_143
#AT_START_144
at_fn_group_banner 144 'mat5_compressed_read_le.at:3560' \
  "Read cell array structure arrays (character fields)" "" 4
at_xfail=no
(
  $as_echo "144. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_le.at:3561" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_le.at:3561"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_le.at:3615: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_le.mat var69"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var69" "mat5_compressed_read_le.at:3615"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_le.mat var69
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var69
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_le.at:3615"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_144
#AT_START_145
at_fn_group_banner 145 'mat5_uncompressed_read_be.at:27' \
  "Read 2D double-precision array" "                 " 5
at_xfail=no
(
  $as_echo "145. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:41: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var1" "mat5_uncompressed_read_be.at:41"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:41"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_145
#AT_START_146
at_fn_group_banner 146 'mat5_uncompressed_read_be.at:44' \
  "Read 2D single-precision array" "                 " 5
at_xfail=no
(
  $as_echo "146. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:58: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var2" "mat5_uncompressed_read_be.at:58"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var2
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:58"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_146
#AT_START_147
at_fn_group_banner 147 'mat5_uncompressed_read_be.at:61' \
  "Read 2D 64-bit integer array" "                   " 5
at_xfail=no
(
  $as_echo "147. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:75: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var3" "mat5_uncompressed_read_be.at:75"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var3
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:75"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_147
#AT_START_148
at_fn_group_banner 148 'mat5_uncompressed_read_be.at:78' \
  "Read 2D 64-bit unsigned integer array" "          " 5
at_xfail=no
(
  $as_echo "148. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:92: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var4" "mat5_uncompressed_read_be.at:92"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var4
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:92"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_148
#AT_START_149
at_fn_group_banner 149 'mat5_uncompressed_read_be.at:95' \
  "Read 2D 32-bit integer array" "                   " 5
at_xfail=no
(
  $as_echo "149. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:109: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var5"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var5" "mat5_uncompressed_read_be.at:109"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var5
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var5
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:109"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_149
#AT_START_150
at_fn_group_banner 150 'mat5_uncompressed_read_be.at:112' \
  "Read 2D 32-bit unsigned integer array" "          " 5
at_xfail=no
(
  $as_echo "150. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:126: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var6"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var6" "mat5_uncompressed_read_be.at:126"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var6
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var6
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:126"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_150
#AT_START_151
at_fn_group_banner 151 'mat5_uncompressed_read_be.at:129' \
  "Read 2D 16-bit integer array" "                   " 5
at_xfail=no
(
  $as_echo "151. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:143: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var7"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var7" "mat5_uncompressed_read_be.at:143"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var7
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var7
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:143"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_151
#AT_START_152
at_fn_group_banner 152 'mat5_uncompressed_read_be.at:146' \
  "Read 2D 16-bit unsigned integer array" "          " 5
at_xfail=no
(
  $as_echo "152. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:160: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var8"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var8" "mat5_uncompressed_read_be.at:160"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var8
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var8
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:160"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_152
#AT_START_153
at_fn_group_banner 153 'mat5_uncompressed_read_be.at:163' \
  "Read 2D 8-bit integer array" "                    " 5
at_xfail=no
(
  $as_echo "153. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:177: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var9"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var9" "mat5_uncompressed_read_be.at:177"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var9
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var9
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:177"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_153
#AT_START_154
at_fn_group_banner 154 'mat5_uncompressed_read_be.at:180' \
  "Read 2D 8-bit unsigned integer array" "           " 5
at_xfail=no
(
  $as_echo "154. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:194: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var10"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var10" "mat5_uncompressed_read_be.at:194"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var10
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var10
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:194"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_154
#AT_START_155
at_fn_group_banner 155 'mat5_uncompressed_read_be.at:197' \
  "Read 2D double-precision complex array" "         " 5
at_xfail=no
(
  $as_echo "155. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:211: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var11" "mat5_uncompressed_read_be.at:211"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:211"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_155
#AT_START_156
at_fn_group_banner 156 'mat5_uncompressed_read_be.at:214' \
  "Read 2D single-precision complex array" "         " 5
at_xfail=no
(
  $as_echo "156. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:228: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var12"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var12" "mat5_uncompressed_read_be.at:228"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var12
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var12
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:228"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_156
#AT_START_157
at_fn_group_banner 157 'mat5_uncompressed_read_be.at:231' \
  "Read 2D 64-bit integer complex array" "           " 5
at_xfail=no
(
  $as_echo "157. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:245: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var13"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var13" "mat5_uncompressed_read_be.at:245"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var13
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var13
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:245"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_157
#AT_START_158
at_fn_group_banner 158 'mat5_uncompressed_read_be.at:248' \
  "Read 2D 64-bit unsigned integer complex array" "  " 5
at_xfail=no
(
  $as_echo "158. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:262: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var14"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var14" "mat5_uncompressed_read_be.at:262"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var14
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var14
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:262"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_158
#AT_START_159
at_fn_group_banner 159 'mat5_uncompressed_read_be.at:265' \
  "Read 2D 32-bit integer complex array" "           " 5
at_xfail=no
(
  $as_echo "159. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:279: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var15"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var15" "mat5_uncompressed_read_be.at:279"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var15
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var15
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:279"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_159
#AT_START_160
at_fn_group_banner 160 'mat5_uncompressed_read_be.at:282' \
  "Read 2D 32-bit unsigned integer complex array" "  " 5
at_xfail=no
(
  $as_echo "160. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:296: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var16"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var16" "mat5_uncompressed_read_be.at:296"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var16
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var16
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:296"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_160
#AT_START_161
at_fn_group_banner 161 'mat5_uncompressed_read_be.at:299' \
  "Read 2D 16-bit integer complex array" "           " 5
at_xfail=no
(
  $as_echo "161. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:313: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var17"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var17" "mat5_uncompressed_read_be.at:313"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var17
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var17
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:313"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_161
#AT_START_162
at_fn_group_banner 162 'mat5_uncompressed_read_be.at:316' \
  "Read 2D 16-bit unsigned integer complex array" "  " 5
at_xfail=no
(
  $as_echo "162. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:330: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var18"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var18" "mat5_uncompressed_read_be.at:330"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var18
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var18
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:330"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_162
#AT_START_163
at_fn_group_banner 163 'mat5_uncompressed_read_be.at:333' \
  "Read 2D 8-bit integer complex array" "            " 5
at_xfail=no
(
  $as_echo "163. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:347: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var19"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var19" "mat5_uncompressed_read_be.at:347"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var19
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var19
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:347"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_163
#AT_START_164
at_fn_group_banner 164 'mat5_uncompressed_read_be.at:350' \
  "Read 2D 8-bit unsigned integer complex array" "   " 5
at_xfail=no
(
  $as_echo "164. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:364: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var20"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var20" "mat5_uncompressed_read_be.at:364"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var20
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var20
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:364"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_164
#AT_START_165
at_fn_group_banner 165 'mat5_uncompressed_read_be.at:367' \
  "Read double-precision sparse array" "             " 5
at_xfail=no
(
  $as_echo "165. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:382: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var21"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var21" "mat5_uncompressed_read_be.at:382"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var21
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var21
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,2)  2
    (3,3)  3
    (4,4)  4
    (5,5)  5
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:382"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_165
#AT_START_166
at_fn_group_banner 166 'mat5_uncompressed_read_be.at:385' \
  "Read double-precision sparse complex array" "     " 5
at_xfail=no
(
  $as_echo "166. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:400: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var22"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var22" "mat5_uncompressed_read_be.at:400"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var22
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var22
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 6i
    (2,2)  2 + 7i
    (3,3)  3 + 8i
    (4,4)  4 + 9i
    (5,5)  5 + 10i
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:400"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_166
#AT_START_167
at_fn_group_banner 167 'mat5_uncompressed_read_be.at:403' \
  "Read empty array" "                               " 5
at_xfail=no
(
  $as_echo "167. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:410: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var23"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var23" "mat5_uncompressed_read_be.at:410"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var23
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var23
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:410"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_167
#AT_START_168
at_fn_group_banner 168 'mat5_uncompressed_read_be.at:413' \
  "Read 2D character array" "                        " 5
at_xfail=no
(
  $as_echo "168. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:427: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var24" "mat5_uncompressed_read_be.at:427"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:427"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_168
#AT_START_169
at_fn_group_banner 169 'mat5_uncompressed_read_be.at:430' \
  "Read empty structure array" "                     " 5
at_xfail=no
(
  $as_echo "169. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:440: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var25"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var25" "mat5_uncompressed_read_be.at:440"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var25
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var25
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:440"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_169
#AT_START_170
at_fn_group_banner 170 'mat5_uncompressed_read_be.at:442' \
  "Read empty structure array with fields" "         " 5
at_xfail=no
(
  $as_echo "170. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:456: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var26"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var26" "mat5_uncompressed_read_be.at:456"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var26
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var26
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:456"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_170
#AT_START_171
at_fn_group_banner 171 'mat5_uncompressed_read_be.at:458' \
  "Read structure array with empty fields" "         " 5
at_xfail=no
(
  $as_echo "171. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:490: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var27"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var27" "mat5_uncompressed_read_be.at:490"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var27
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var27
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:490"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_171
#AT_START_172
at_fn_group_banner 172 'mat5_uncompressed_read_be.at:492' \
  "Read structure array with double-precision fields" "" 5
at_xfail=no
(
  $as_echo "172. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:538: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var28"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var28" "mat5_uncompressed_read_be.at:538"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var28
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var28
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:538"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_172
#AT_START_173
at_fn_group_banner 173 'mat5_uncompressed_read_be.at:540' \
  "Read structure array with single-precision fields" "" 5
at_xfail=no
(
  $as_echo "173. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:586: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var29"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var29" "mat5_uncompressed_read_be.at:586"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var29
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var29
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:586"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_173
#AT_START_174
at_fn_group_banner 174 'mat5_uncompressed_read_be.at:588' \
  "Read structure array with 64-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "174. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:634: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var30"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var30" "mat5_uncompressed_read_be.at:634"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var30
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var30
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:634"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_174
#AT_START_175
at_fn_group_banner 175 'mat5_uncompressed_read_be.at:636' \
  "Read structure array with 64-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "175. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:682: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var31"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var31" "mat5_uncompressed_read_be.at:682"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var31
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var31
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:682"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_175
#AT_START_176
at_fn_group_banner 176 'mat5_uncompressed_read_be.at:684' \
  "Read structure array with 32-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "176. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:730: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var32"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var32" "mat5_uncompressed_read_be.at:730"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var32
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var32
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:730"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_176
#AT_START_177
at_fn_group_banner 177 'mat5_uncompressed_read_be.at:732' \
  "Read structure array with 32-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "177. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:778: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var33"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var33" "mat5_uncompressed_read_be.at:778"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var33
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var33
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:778"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_177
#AT_START_178
at_fn_group_banner 178 'mat5_uncompressed_read_be.at:780' \
  "Read structure array with 16-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "178. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:826: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var34"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var34" "mat5_uncompressed_read_be.at:826"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var34
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var34
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:826"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_178
#AT_START_179
at_fn_group_banner 179 'mat5_uncompressed_read_be.at:828' \
  "Read structure array with 16-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "179. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:874: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var35"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var35" "mat5_uncompressed_read_be.at:874"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var35
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var35
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:874"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_179
#AT_START_180
at_fn_group_banner 180 'mat5_uncompressed_read_be.at:876' \
  "Read structure array with 8-bit integer fields" " " 5
at_xfail=no
(
  $as_echo "180. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:922: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var36"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var36" "mat5_uncompressed_read_be.at:922"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var36
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var36
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:922"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_180
#AT_START_181
at_fn_group_banner 181 'mat5_uncompressed_read_be.at:924' \
  "Read structure array with 8-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "181. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:970: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var37"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var37" "mat5_uncompressed_read_be.at:970"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var37
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var37
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:970"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_181
#AT_START_182
at_fn_group_banner 182 'mat5_uncompressed_read_be.at:972' \
  "Read structure array with complex double-precision fields" "" 5
at_xfail=no
(
  $as_echo "182. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1018: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var38"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var38" "mat5_uncompressed_read_be.at:1018"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var38
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var38
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1018"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_182
#AT_START_183
at_fn_group_banner 183 'mat5_uncompressed_read_be.at:1020' \
  "Read structure array with complex single-precision fields" "" 5
at_xfail=no
(
  $as_echo "183. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1066: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var39"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var39" "mat5_uncompressed_read_be.at:1066"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var39
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var39
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1066"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_183
#AT_START_184
at_fn_group_banner 184 'mat5_uncompressed_read_be.at:1068' \
  "Read structure array with complex 64-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "184. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1114: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var40"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var40" "mat5_uncompressed_read_be.at:1114"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var40
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var40
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1114"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_184
#AT_START_185
at_fn_group_banner 185 'mat5_uncompressed_read_be.at:1116' \
  "Read structure array with complex 64-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "185. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1162: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var41"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var41" "mat5_uncompressed_read_be.at:1162"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var41
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var41
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1162"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_185
#AT_START_186
at_fn_group_banner 186 'mat5_uncompressed_read_be.at:1164' \
  "Read structure array with complex 32-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "186. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1210: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var42"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var42" "mat5_uncompressed_read_be.at:1210"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var42
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var42
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1210"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_186
#AT_START_187
at_fn_group_banner 187 'mat5_uncompressed_read_be.at:1212' \
  "Read structure array with complex 32-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "187. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1258: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var43"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var43" "mat5_uncompressed_read_be.at:1258"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var43
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var43
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1258"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_187
#AT_START_188
at_fn_group_banner 188 'mat5_uncompressed_read_be.at:1260' \
  "Read structure array with complex 16-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "188. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1306: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var44"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var44" "mat5_uncompressed_read_be.at:1306"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var44
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var44
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1306"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_188
#AT_START_189
at_fn_group_banner 189 'mat5_uncompressed_read_be.at:1308' \
  "Read structure array with complex 16-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "189. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1354: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var45"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var45" "mat5_uncompressed_read_be.at:1354"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var45
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var45
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1354"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_189
#AT_START_190
at_fn_group_banner 190 'mat5_uncompressed_read_be.at:1356' \
  "Read structure array with complex 8-bit integer fields" "" 5
at_xfail=no
(
  $as_echo "190. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1402: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var46"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var46" "mat5_uncompressed_read_be.at:1402"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var46
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var46
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1402"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_190
#AT_START_191
at_fn_group_banner 191 'mat5_uncompressed_read_be.at:1404' \
  "Read structure array with complex 8-bit unsigned integer fields" "" 5
at_xfail=no
(
  $as_echo "191. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1450: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var47"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var47" "mat5_uncompressed_read_be.at:1450"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var47
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var47
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1450"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_191
#AT_START_192
at_fn_group_banner 192 'mat5_uncompressed_read_be.at:1453' \
  "Read structure array with double-precision sparse fields" "" 5
at_xfail=no
(
  $as_echo "192. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1505: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var48"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var48" "mat5_uncompressed_read_be.at:1505"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var48
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var48
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1505"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_192
#AT_START_193
at_fn_group_banner 193 'mat5_uncompressed_read_be.at:1508' \
  "Read structure array with complex double-precision sparse fields" "" 5
at_xfail=no
(
  $as_echo "193. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1560: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var49"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var49" "mat5_uncompressed_read_be.at:1560"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var49
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var49
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1560"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_193
#AT_START_194
at_fn_group_banner 194 'mat5_uncompressed_read_be.at:1563' \
  "Read structure array with character fields" "     " 5
at_xfail=no
(
  $as_echo "194. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1605: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var50"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var50" "mat5_uncompressed_read_be.at:1605"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var50
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var50
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1605"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_194
#AT_START_195
at_fn_group_banner 195 'mat5_uncompressed_read_be.at:1608' \
  "Read empty cell array" "                          " 5
at_xfail=no
(
  $as_echo "195. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1618: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var51"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var51" "mat5_uncompressed_read_be.at:1618"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var51
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var51
      Rank: 2
Dimensions: 0 x 0
Class Type: Cell Array
 Data Type: Cell Array
{
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1618"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_195
#AT_START_196
at_fn_group_banner 196 'mat5_uncompressed_read_be.at:1621' \
  "Read cell array with empty arrays" "              " 5
at_xfail=no
(
  $as_echo "196. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1661: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var52"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var52" "mat5_uncompressed_read_be.at:1661"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var52
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var52
      Rank: 2
Dimensions: 1 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: Single Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, unsigned integer array
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1661"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_196
#AT_START_197
at_fn_group_banner 197 'mat5_uncompressed_read_be.at:1664' \
  "Read cell array with double-precision arrays" "   " 5
at_xfail=no
(
  $as_echo "197. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1725: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var53"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var53" "mat5_uncompressed_read_be.at:1725"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var53
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var53
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1725"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_197
#AT_START_198
at_fn_group_banner 198 'mat5_uncompressed_read_be.at:1728' \
  "Read cell array with single-precision arrays" "   " 5
at_xfail=no
(
  $as_echo "198. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1789: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var54"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var54" "mat5_uncompressed_read_be.at:1789"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var54
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var54
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1789"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_198
#AT_START_199
at_fn_group_banner 199 'mat5_uncompressed_read_be.at:1792' \
  "Read cell array with 64-bit integer arrays" "     " 5
at_xfail=no
(
  $as_echo "199. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1853: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var55"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var55" "mat5_uncompressed_read_be.at:1853"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var55
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var55
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1853"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_199
#AT_START_200
at_fn_group_banner 200 'mat5_uncompressed_read_be.at:1856' \
  "Read cell array with 64-bit unsigned integer arrays" "" 5
at_xfail=no
(
  $as_echo "200. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1917: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var56"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var56" "mat5_uncompressed_read_be.at:1917"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var56
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var56
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1917"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_200
#AT_START_201
at_fn_group_banner 201 'mat5_uncompressed_read_be.at:1920' \
  "Read cell array with 32-bit integer arrays" "     " 5
at_xfail=no
(
  $as_echo "201. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:1981: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var57"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var57" "mat5_uncompressed_read_be.at:1981"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var57
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var57
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:1981"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_201
#AT_START_202
at_fn_group_banner 202 'mat5_uncompressed_read_be.at:1984' \
  "Read cell array with 32-bit unsigned integer arrays" "" 5
at_xfail=no
(
  $as_echo "202. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2045: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var58"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var58" "mat5_uncompressed_read_be.at:2045"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var58
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var58
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2045"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_202
#AT_START_203
at_fn_group_banner 203 'mat5_uncompressed_read_be.at:2048' \
  "Read cell array with 16-bit integer arrays" "     " 5
at_xfail=no
(
  $as_echo "203. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2109: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var59"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var59" "mat5_uncompressed_read_be.at:2109"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var59
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var59
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2109"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_203
#AT_START_204
at_fn_group_banner 204 'mat5_uncompressed_read_be.at:2112' \
  "Read cell array with 16-bit unsigned integer arrays" "" 5
at_xfail=no
(
  $as_echo "204. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2173: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var60"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var60" "mat5_uncompressed_read_be.at:2173"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var60
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var60
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2173"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_204
#AT_START_205
at_fn_group_banner 205 'mat5_uncompressed_read_be.at:2176' \
  "Read cell array with 8-bit integer arrays" "      " 5
at_xfail=no
(
  $as_echo "205. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2237: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var61"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var61" "mat5_uncompressed_read_be.at:2237"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var61
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var61
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2237"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_205
#AT_START_206
at_fn_group_banner 206 'mat5_uncompressed_read_be.at:2240' \
  "Read cell array with 8-bit unsigned integer arrays" "" 5
at_xfail=no
(
  $as_echo "206. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2301: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var62"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var62" "mat5_uncompressed_read_be.at:2301"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var62
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var62
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2301"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_206
#AT_START_207
at_fn_group_banner 207 'mat5_uncompressed_read_be.at:2304' \
  "Read cell array with double-precision sparse arrays" "" 5
at_xfail=no
(
  $as_echo "207. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2354: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var63"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var63" "mat5_uncompressed_read_be.at:2354"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var63
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var63
      Rank: 2
Dimensions: 1 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2354"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_207
#AT_START_208
at_fn_group_banner 208 'mat5_uncompressed_read_be.at:2357' \
  "Read cell array with complex double-precision sparse arrays" "" 5
at_xfail=no
(
  $as_echo "208. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2407: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var64"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var64" "mat5_uncompressed_read_be.at:2407"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var64
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var64
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2407"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_208
#AT_START_209
at_fn_group_banner 209 'mat5_uncompressed_read_be.at:2410' \
  "Read cell array with character arrays" "          " 5
at_xfail=no
(
  $as_echo "209. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2448: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var65"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var65" "mat5_uncompressed_read_be.at:2448"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var65
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var65
      Rank: 2
Dimensions: 2 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2448"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_209
#AT_START_210
at_fn_group_banner 210 'mat5_uncompressed_read_be.at:2451' \
  "Read cell array with empty structure arrays" "    " 5
at_xfail=no
(
  $as_echo "210. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:2505: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var66"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var66" "mat5_uncompressed_read_be.at:2505"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var66
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var66
      Rank: 2
Dimensions: 1 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:2505"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_210
#AT_START_211
at_fn_group_banner 211 'mat5_uncompressed_read_be.at:2508' \
  "Read cell array with structure arrays (numeric fields)" "" 5
at_xfail=no
(
  $as_echo "211. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:3358: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var67"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var67" "mat5_uncompressed_read_be.at:3358"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var67
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var67
      Rank: 2
Dimensions: 2 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:3358"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_211
#AT_START_212
at_fn_group_banner 212 'mat5_uncompressed_read_be.at:3361' \
  "Read cell array with structure arrays (sparse fields)" "" 5
at_xfail=no
(
  $as_echo "212. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:3467: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var68"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var68" "mat5_uncompressed_read_be.at:3467"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var68
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var68
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:3467"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_212
#AT_START_213
at_fn_group_banner 213 'mat5_uncompressed_read_be.at:3470' \
  "Read cell array structure arrays (character fields)" "" 5
at_xfail=no
(
  $as_echo "213. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_read_be.at:3524: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_uncompressed_be.mat var69"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var69" "mat5_uncompressed_read_be.at:3524"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_uncompressed_be.mat var69
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var69
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_read_be.at:3524"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_213
#AT_START_214
at_fn_group_banner 214 'mat5_compressed_read_be.at:27' \
  "Read 2D double-precision array" "                 " 6
at_xfail=no
(
  $as_echo "214. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:28" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:28"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:42: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var1" "mat5_compressed_read_be.at:42"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:42"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_214
#AT_START_215
at_fn_group_banner 215 'mat5_compressed_read_be.at:45' \
  "Read 2D single-precision array" "                 " 6
at_xfail=no
(
  $as_echo "215. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:46" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:46"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:60: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var2" "mat5_compressed_read_be.at:60"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var2
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:60"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_215
#AT_START_216
at_fn_group_banner 216 'mat5_compressed_read_be.at:63' \
  "Read 2D 64-bit integer array" "                   " 6
at_xfail=no
(
  $as_echo "216. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:64" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:64"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:78: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var3" "mat5_compressed_read_be.at:78"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var3
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:78"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_216
#AT_START_217
at_fn_group_banner 217 'mat5_compressed_read_be.at:81' \
  "Read 2D 64-bit unsigned integer array" "          " 6
at_xfail=no
(
  $as_echo "217. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:82" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:82"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:96: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var4" "mat5_compressed_read_be.at:96"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var4
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:96"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_217
#AT_START_218
at_fn_group_banner 218 'mat5_compressed_read_be.at:99' \
  "Read 2D 32-bit integer array" "                   " 6
at_xfail=no
(
  $as_echo "218. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:100" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:100"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:114: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var5"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var5" "mat5_compressed_read_be.at:114"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var5
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var5
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:114"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_218
#AT_START_219
at_fn_group_banner 219 'mat5_compressed_read_be.at:117' \
  "Read 2D 32-bit unsigned integer array" "          " 6
at_xfail=no
(
  $as_echo "219. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:118" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:118"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:132: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var6"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var6" "mat5_compressed_read_be.at:132"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var6
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var6
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:132"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_219
#AT_START_220
at_fn_group_banner 220 'mat5_compressed_read_be.at:135' \
  "Read 2D 16-bit integer array" "                   " 6
at_xfail=no
(
  $as_echo "220. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:136" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:136"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:150: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var7"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var7" "mat5_compressed_read_be.at:150"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var7
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var7
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:150"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_220
#AT_START_221
at_fn_group_banner 221 'mat5_compressed_read_be.at:153' \
  "Read 2D 16-bit unsigned integer array" "          " 6
at_xfail=no
(
  $as_echo "221. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:154" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:154"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:168: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var8"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var8" "mat5_compressed_read_be.at:168"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var8
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var8
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:168"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_221
#AT_START_222
at_fn_group_banner 222 'mat5_compressed_read_be.at:171' \
  "Read 2D 8-bit integer array" "                    " 6
at_xfail=no
(
  $as_echo "222. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:172" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:172"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:186: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var9"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var9" "mat5_compressed_read_be.at:186"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var9
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var9
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:186"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_222
#AT_START_223
at_fn_group_banner 223 'mat5_compressed_read_be.at:189' \
  "Read 2D 8-bit unsigned integer array" "           " 6
at_xfail=no
(
  $as_echo "223. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:190" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:190"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:204: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var10"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var10" "mat5_compressed_read_be.at:204"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var10
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var10
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:204"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_223
#AT_START_224
at_fn_group_banner 224 'mat5_compressed_read_be.at:207' \
  "Read 2D double-precision complex array" "         " 6
at_xfail=no
(
  $as_echo "224. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:208" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:208"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:222: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var11" "mat5_compressed_read_be.at:222"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:222"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_224
#AT_START_225
at_fn_group_banner 225 'mat5_compressed_read_be.at:225' \
  "Read 2D single-precision complex array" "         " 6
at_xfail=no
(
  $as_echo "225. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:226" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:226"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:240: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var12"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var12" "mat5_compressed_read_be.at:240"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var12
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var12
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:240"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_225
#AT_START_226
at_fn_group_banner 226 'mat5_compressed_read_be.at:243' \
  "Read 2D 64-bit integer complex array" "           " 6
at_xfail=no
(
  $as_echo "226. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:244" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:244"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:258: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var13"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var13" "mat5_compressed_read_be.at:258"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var13
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var13
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:258"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_226
#AT_START_227
at_fn_group_banner 227 'mat5_compressed_read_be.at:261' \
  "Read 2D 64-bit unsigned integer complex array" "  " 6
at_xfail=no
(
  $as_echo "227. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:262" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:262"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:276: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var14"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var14" "mat5_compressed_read_be.at:276"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var14
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var14
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:276"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_227
#AT_START_228
at_fn_group_banner 228 'mat5_compressed_read_be.at:279' \
  "Read 2D 32-bit integer complex array" "           " 6
at_xfail=no
(
  $as_echo "228. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:280" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:280"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:294: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var15"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var15" "mat5_compressed_read_be.at:294"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var15
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var15
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:294"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_228
#AT_START_229
at_fn_group_banner 229 'mat5_compressed_read_be.at:297' \
  "Read 2D 32-bit unsigned integer complex array" "  " 6
at_xfail=no
(
  $as_echo "229. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:298" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:298"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:312: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var16"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var16" "mat5_compressed_read_be.at:312"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var16
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var16
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:312"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_229
#AT_START_230
at_fn_group_banner 230 'mat5_compressed_read_be.at:315' \
  "Read 2D 16-bit integer complex array" "           " 6
at_xfail=no
(
  $as_echo "230. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:316" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:316"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:330: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var17"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var17" "mat5_compressed_read_be.at:330"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var17
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var17
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:330"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_230
#AT_START_231
at_fn_group_banner 231 'mat5_compressed_read_be.at:333' \
  "Read 2D 16-bit unsigned integer complex array" "  " 6
at_xfail=no
(
  $as_echo "231. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:334" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:334"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:348: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var18"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var18" "mat5_compressed_read_be.at:348"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var18
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var18
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:348"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_231
#AT_START_232
at_fn_group_banner 232 'mat5_compressed_read_be.at:351' \
  "Read 2D 8-bit integer complex array" "            " 6
at_xfail=no
(
  $as_echo "232. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:352" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:352"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:366: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var19"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var19" "mat5_compressed_read_be.at:366"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var19
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var19
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:366"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_232
#AT_START_233
at_fn_group_banner 233 'mat5_compressed_read_be.at:369' \
  "Read 2D 8-bit unsigned integer complex array" "   " 6
at_xfail=no
(
  $as_echo "233. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:370" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:370"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:384: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var20"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var20" "mat5_compressed_read_be.at:384"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var20
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var20
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:384"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_233
#AT_START_234
at_fn_group_banner 234 'mat5_compressed_read_be.at:387' \
  "Read double-precision sparse array" "             " 6
at_xfail=no
(
  $as_echo "234. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:388" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:388"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:403: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var21"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var21" "mat5_compressed_read_be.at:403"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var21
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var21
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,2)  2
    (3,3)  3
    (4,4)  4
    (5,5)  5
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:403"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_234
#AT_START_235
at_fn_group_banner 235 'mat5_compressed_read_be.at:406' \
  "Read double-precision sparse complex array" "     " 6
at_xfail=no
(
  $as_echo "235. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:407" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:407"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:422: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var22"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var22" "mat5_compressed_read_be.at:422"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var22
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var22
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 6i
    (2,2)  2 + 7i
    (3,3)  3 + 8i
    (4,4)  4 + 9i
    (5,5)  5 + 10i
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_235
#AT_START_236
at_fn_group_banner 236 'mat5_compressed_read_be.at:425' \
  "Read empty array" "                               " 6
at_xfail=no
(
  $as_echo "236. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:426" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:426"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:433: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var23"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var23" "mat5_compressed_read_be.at:433"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var23
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var23
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:433"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_236
#AT_START_237
at_fn_group_banner 237 'mat5_compressed_read_be.at:436' \
  "Read 2D character array" "                        " 6
at_xfail=no
(
  $as_echo "237. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:437" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:437"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:451: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var24" "mat5_compressed_read_be.at:451"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:451"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_237
#AT_START_238
at_fn_group_banner 238 'mat5_compressed_read_be.at:454' \
  "Read empty structure array" "                     " 6
at_xfail=no
(
  $as_echo "238. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:455" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:455"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:465: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var25"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var25" "mat5_compressed_read_be.at:465"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var25
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var25
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:465"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_238
#AT_START_239
at_fn_group_banner 239 'mat5_compressed_read_be.at:467' \
  "Read empty structure array with fields" "         " 6
at_xfail=no
(
  $as_echo "239. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:468" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:468"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:482: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var26"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var26" "mat5_compressed_read_be.at:482"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var26
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var26
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:482"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_239
#AT_START_240
at_fn_group_banner 240 'mat5_compressed_read_be.at:484' \
  "Read structure array with empty fields" "         " 6
at_xfail=no
(
  $as_echo "240. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:485" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:485"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:517: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var27"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var27" "mat5_compressed_read_be.at:517"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var27
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var27
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:517"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_240
#AT_START_241
at_fn_group_banner 241 'mat5_compressed_read_be.at:519' \
  "Read structure array with double-precision fields" "" 6
at_xfail=no
(
  $as_echo "241. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:520" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:520"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:566: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var28"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var28" "mat5_compressed_read_be.at:566"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var28
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var28
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:566"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_241
#AT_START_242
at_fn_group_banner 242 'mat5_compressed_read_be.at:568' \
  "Read structure array with single-precision fields" "" 6
at_xfail=no
(
  $as_echo "242. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:569" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:569"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:615: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var29"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var29" "mat5_compressed_read_be.at:615"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var29
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var29
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:615"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_242
#AT_START_243
at_fn_group_banner 243 'mat5_compressed_read_be.at:617' \
  "Read structure array with 64-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "243. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:618" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:618"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:664: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var30"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var30" "mat5_compressed_read_be.at:664"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var30
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var30
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:664"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_243
#AT_START_244
at_fn_group_banner 244 'mat5_compressed_read_be.at:666' \
  "Read structure array with 64-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "244. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:667" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:667"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:713: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var31"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var31" "mat5_compressed_read_be.at:713"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var31
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var31
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:713"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_244
#AT_START_245
at_fn_group_banner 245 'mat5_compressed_read_be.at:715' \
  "Read structure array with 32-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "245. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:716" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:716"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:762: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var32"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var32" "mat5_compressed_read_be.at:762"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var32
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var32
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:762"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_245
#AT_START_246
at_fn_group_banner 246 'mat5_compressed_read_be.at:764' \
  "Read structure array with 32-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "246. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:765" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:765"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:811: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var33"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var33" "mat5_compressed_read_be.at:811"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var33
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var33
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:811"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_246
#AT_START_247
at_fn_group_banner 247 'mat5_compressed_read_be.at:813' \
  "Read structure array with 16-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "247. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:814" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:814"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:860: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var34"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var34" "mat5_compressed_read_be.at:860"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var34
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var34
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:860"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_247
#AT_START_248
at_fn_group_banner 248 'mat5_compressed_read_be.at:862' \
  "Read structure array with 16-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "248. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:863" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:863"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:909: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var35"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var35" "mat5_compressed_read_be.at:909"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var35
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var35
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:909"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_248
#AT_START_249
at_fn_group_banner 249 'mat5_compressed_read_be.at:911' \
  "Read structure array with 8-bit integer fields" " " 6
at_xfail=no
(
  $as_echo "249. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:912" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:912"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:958: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var36"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var36" "mat5_compressed_read_be.at:958"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var36
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var36
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:958"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_249
#AT_START_250
at_fn_group_banner 250 'mat5_compressed_read_be.at:960' \
  "Read structure array with 8-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "250. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:961" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:961"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1007: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var37"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var37" "mat5_compressed_read_be.at:1007"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var37
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var37
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1007"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_250
#AT_START_251
at_fn_group_banner 251 'mat5_compressed_read_be.at:1009' \
  "Read structure array with complex double-precision fields" "" 6
at_xfail=no
(
  $as_echo "251. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1010" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1010"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1056: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var38"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var38" "mat5_compressed_read_be.at:1056"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var38
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var38
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1056"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_251
#AT_START_252
at_fn_group_banner 252 'mat5_compressed_read_be.at:1058' \
  "Read structure array with complex single-precision fields" "" 6
at_xfail=no
(
  $as_echo "252. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1059" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1059"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1105: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var39"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var39" "mat5_compressed_read_be.at:1105"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var39
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var39
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1105"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_252
#AT_START_253
at_fn_group_banner 253 'mat5_compressed_read_be.at:1107' \
  "Read structure array with complex 64-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "253. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1108" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1108"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1154: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var40"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var40" "mat5_compressed_read_be.at:1154"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var40
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var40
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1154"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_253
#AT_START_254
at_fn_group_banner 254 'mat5_compressed_read_be.at:1156' \
  "Read structure array with complex 64-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "254. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1157" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1157"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1203: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var41"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var41" "mat5_compressed_read_be.at:1203"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var41
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var41
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1203"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_254
#AT_START_255
at_fn_group_banner 255 'mat5_compressed_read_be.at:1205' \
  "Read structure array with complex 32-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "255. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1206" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1206"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1252: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var42"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var42" "mat5_compressed_read_be.at:1252"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var42
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var42
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1252"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_255
#AT_START_256
at_fn_group_banner 256 'mat5_compressed_read_be.at:1254' \
  "Read structure array with complex 32-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "256. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1255" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1255"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1301: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var43"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var43" "mat5_compressed_read_be.at:1301"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var43
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var43
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1301"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_256
#AT_START_257
at_fn_group_banner 257 'mat5_compressed_read_be.at:1303' \
  "Read structure array with complex 16-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "257. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1304" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1304"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1350: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var44"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var44" "mat5_compressed_read_be.at:1350"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var44
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var44
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1350"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_257
#AT_START_258
at_fn_group_banner 258 'mat5_compressed_read_be.at:1352' \
  "Read structure array with complex 16-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "258. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1353" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1353"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1399: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var45"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var45" "mat5_compressed_read_be.at:1399"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var45
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var45
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1399"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_258
#AT_START_259
at_fn_group_banner 259 'mat5_compressed_read_be.at:1401' \
  "Read structure array with complex 8-bit integer fields" "" 6
at_xfail=no
(
  $as_echo "259. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1402" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1402"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1448: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var46"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var46" "mat5_compressed_read_be.at:1448"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var46
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var46
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1448"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_259
#AT_START_260
at_fn_group_banner 260 'mat5_compressed_read_be.at:1450' \
  "Read structure array with complex 8-bit unsigned integer fields" "" 6
at_xfail=no
(
  $as_echo "260. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1451" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1451"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1497: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var47"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var47" "mat5_compressed_read_be.at:1497"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var47
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var47
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1497"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_260
#AT_START_261
at_fn_group_banner 261 'mat5_compressed_read_be.at:1500' \
  "Read structure array with double-precision sparse fields" "" 6
at_xfail=no
(
  $as_echo "261. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1501" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1501"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1553: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var48"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var48" "mat5_compressed_read_be.at:1553"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var48
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var48
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1553"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_261
#AT_START_262
at_fn_group_banner 262 'mat5_compressed_read_be.at:1556' \
  "Read structure array with complex double-precision sparse fields" "" 6
at_xfail=no
(
  $as_echo "262. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1557" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1557"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1609: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var49"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var49" "mat5_compressed_read_be.at:1609"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var49
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var49
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1609"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_262
#AT_START_263
at_fn_group_banner 263 'mat5_compressed_read_be.at:1612' \
  "Read structure array with character fields" "     " 6
at_xfail=no
(
  $as_echo "263. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1613" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1613"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1655: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var50"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var50" "mat5_compressed_read_be.at:1655"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var50
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var50
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1655"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_263
#AT_START_264
at_fn_group_banner 264 'mat5_compressed_read_be.at:1658' \
  "Read empty cell array" "                          " 6
at_xfail=no
(
  $as_echo "264. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1659" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1659"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1669: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var51"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var51" "mat5_compressed_read_be.at:1669"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var51
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var51
      Rank: 2
Dimensions: 0 x 0
Class Type: Cell Array
 Data Type: Cell Array
{
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1669"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_264
#AT_START_265
at_fn_group_banner 265 'mat5_compressed_read_be.at:1672' \
  "Read cell array with empty arrays" "              " 6
at_xfail=no
(
  $as_echo "265. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1673" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1673"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1713: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var52"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var52" "mat5_compressed_read_be.at:1713"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var52
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var52
      Rank: 2
Dimensions: 1 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: Single Precision Array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, unsigned integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, signed integer array
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, unsigned integer array
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1713"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_265
#AT_START_266
at_fn_group_banner 266 'mat5_compressed_read_be.at:1716' \
  "Read cell array with double-precision arrays" "   " 6
at_xfail=no
(
  $as_echo "266. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1717" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1717"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1778: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var53"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var53" "mat5_compressed_read_be.at:1778"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var53
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var53
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1778"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_266
#AT_START_267
at_fn_group_banner 267 'mat5_compressed_read_be.at:1781' \
  "Read cell array with single-precision arrays" "   " 6
at_xfail=no
(
  $as_echo "267. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1782" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1782"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1843: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var54"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var54" "mat5_compressed_read_be.at:1843"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var54
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var54
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1843"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_267
#AT_START_268
at_fn_group_banner 268 'mat5_compressed_read_be.at:1846' \
  "Read cell array with 64-bit integer arrays" "     " 6
at_xfail=no
(
  $as_echo "268. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1847" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1847"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1908: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var55"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var55" "mat5_compressed_read_be.at:1908"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var55
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var55
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1908"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_268
#AT_START_269
at_fn_group_banner 269 'mat5_compressed_read_be.at:1911' \
  "Read cell array with 64-bit unsigned integer arrays" "" 6
at_xfail=no
(
  $as_echo "269. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1912" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1912"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:1973: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var56"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var56" "mat5_compressed_read_be.at:1973"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var56
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var56
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:1973"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_269
#AT_START_270
at_fn_group_banner 270 'mat5_compressed_read_be.at:1976' \
  "Read cell array with 32-bit integer arrays" "     " 6
at_xfail=no
(
  $as_echo "270. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:1977" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:1977"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2038: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var57"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var57" "mat5_compressed_read_be.at:2038"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var57
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var57
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2038"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_270
#AT_START_271
at_fn_group_banner 271 'mat5_compressed_read_be.at:2041' \
  "Read cell array with 32-bit unsigned integer arrays" "" 6
at_xfail=no
(
  $as_echo "271. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2042" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2042"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2103: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var58"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var58" "mat5_compressed_read_be.at:2103"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var58
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var58
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2103"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_271
#AT_START_272
at_fn_group_banner 272 'mat5_compressed_read_be.at:2106' \
  "Read cell array with 16-bit integer arrays" "     " 6
at_xfail=no
(
  $as_echo "272. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2107" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2107"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2168: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var59"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var59" "mat5_compressed_read_be.at:2168"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var59
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var59
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2168"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_272
#AT_START_273
at_fn_group_banner 273 'mat5_compressed_read_be.at:2171' \
  "Read cell array with 16-bit unsigned integer arrays" "" 6
at_xfail=no
(
  $as_echo "273. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2172" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2172"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2233: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var60"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var60" "mat5_compressed_read_be.at:2233"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var60
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var60
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2233"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_273
#AT_START_274
at_fn_group_banner 274 'mat5_compressed_read_be.at:2236' \
  "Read cell array with 8-bit integer arrays" "      " 6
at_xfail=no
(
  $as_echo "274. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2237" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2237"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2298: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var61"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var61" "mat5_compressed_read_be.at:2298"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var61
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var61
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2298"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_274
#AT_START_275
at_fn_group_banner 275 'mat5_compressed_read_be.at:2301' \
  "Read cell array with 8-bit unsigned integer arrays" "" 6
at_xfail=no
(
  $as_echo "275. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2302" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2302"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2363: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var62"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var62" "mat5_compressed_read_be.at:2363"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var62
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var62
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2363"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_275
#AT_START_276
at_fn_group_banner 276 'mat5_compressed_read_be.at:2366' \
  "Read cell array with double-precision sparse arrays" "" 6
at_xfail=no
(
  $as_echo "276. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2367" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2367"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2417: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var63"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var63" "mat5_compressed_read_be.at:2417"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var63
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var63
      Rank: 2
Dimensions: 1 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2417"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_276
#AT_START_277
at_fn_group_banner 277 'mat5_compressed_read_be.at:2420' \
  "Read cell array with complex double-precision sparse arrays" "" 6
at_xfail=no
(
  $as_echo "277. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2421" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2421"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2471: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var64"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var64" "mat5_compressed_read_be.at:2471"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var64
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var64
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2471"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_277
#AT_START_278
at_fn_group_banner 278 'mat5_compressed_read_be.at:2474' \
  "Read cell array with character arrays" "          " 6
at_xfail=no
(
  $as_echo "278. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2475" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2475"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2513: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var65"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var65" "mat5_compressed_read_be.at:2513"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var65
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var65
      Rank: 2
Dimensions: 2 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2513"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_278
#AT_START_279
at_fn_group_banner 279 'mat5_compressed_read_be.at:2516' \
  "Read cell array with empty structure arrays" "    " 6
at_xfail=no
(
  $as_echo "279. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2517" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2517"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:2571: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var66"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var66" "mat5_compressed_read_be.at:2571"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var66
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var66
      Rank: 2
Dimensions: 1 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:2571"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_279
#AT_START_280
at_fn_group_banner 280 'mat5_compressed_read_be.at:2574' \
  "Read cell array with structure arrays (numeric fields)" "" 6
at_xfail=no
(
  $as_echo "280. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:2575" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:2575"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:3425: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var67"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var67" "mat5_compressed_read_be.at:3425"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var67
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var67
      Rank: 2
Dimensions: 2 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:3425"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_280
#AT_START_281
at_fn_group_banner 281 'mat5_compressed_read_be.at:3428' \
  "Read cell array with structure arrays (sparse fields)" "" 6
at_xfail=no
(
  $as_echo "281. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:3429" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:3429"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:3535: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var68"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var68" "mat5_compressed_read_be.at:3535"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var68
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var68
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:3535"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_281
#AT_START_282
at_fn_group_banner 282 'mat5_compressed_read_be.at:3538' \
  "Read cell array structure arrays (character fields)" "" 6
at_xfail=no
(
  $as_echo "282. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_read_be.at:3539" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_read_be.at:3539"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_read_be.at:3593: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_compressed_be.mat var69"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var69" "mat5_compressed_read_be.at:3593"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_compressed_be.mat var69
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var69
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_read_be.at:3593"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_282
#AT_START_283
at_fn_group_banner 283 'mat73_read_le.at:27' \
  "Read 2D double-precision array" "                 " 7
at_xfail=no
(
  $as_echo "283. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:28: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:28"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:28"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:42: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var1" "mat73_read_le.at:42"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:42"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_283
#AT_START_284
at_fn_group_banner 284 'mat73_read_le.at:45' \
  "Read 2D single-precision array" "                 " 7
at_xfail=no
(
  $as_echo "284. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:46: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:46"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:46"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:60: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var2" "mat73_read_le.at:60"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var2
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:60"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_284
#AT_START_285
at_fn_group_banner 285 'mat73_read_le.at:63' \
  "Read 2D 64-bit integer array" "                   " 7
at_xfail=no
(
  $as_echo "285. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:64: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:64"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:64"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:78: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var3" "mat73_read_le.at:78"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var3
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:78"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_285
#AT_START_286
at_fn_group_banner 286 'mat73_read_le.at:81' \
  "Read 2D 64-bit unsigned integer array" "          " 7
at_xfail=no
(
  $as_echo "286. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:82: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:82"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:82"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:96: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var4" "mat73_read_le.at:96"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var4
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:96"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_286
#AT_START_287
at_fn_group_banner 287 'mat73_read_le.at:99' \
  "Read 2D 32-bit integer array" "                   " 7
at_xfail=no
(
  $as_echo "287. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:100: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:100"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:100"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:114: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var5"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var5" "mat73_read_le.at:114"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var5
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var5
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:114"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_287
#AT_START_288
at_fn_group_banner 288 'mat73_read_le.at:117' \
  "Read 2D 32-bit unsigned integer array" "          " 7
at_xfail=no
(
  $as_echo "288. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:118: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:118"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:118"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:132: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var6"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var6" "mat73_read_le.at:132"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var6
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var6
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:132"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_288
#AT_START_289
at_fn_group_banner 289 'mat73_read_le.at:135' \
  "Read 2D 16-bit integer array" "                   " 7
at_xfail=no
(
  $as_echo "289. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:136: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:136"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:136"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:150: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var7"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var7" "mat73_read_le.at:150"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var7
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var7
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:150"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_289
#AT_START_290
at_fn_group_banner 290 'mat73_read_le.at:153' \
  "Read 2D 16-bit unsigned integer array" "          " 7
at_xfail=no
(
  $as_echo "290. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:154: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:154"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:154"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:168: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var8"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var8" "mat73_read_le.at:168"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var8
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var8
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:168"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_290
#AT_START_291
at_fn_group_banner 291 'mat73_read_le.at:171' \
  "Read 2D 8-bit integer array" "                    " 7
at_xfail=no
(
  $as_echo "291. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:172: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:172"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:172"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:186: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var9"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var9" "mat73_read_le.at:186"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var9
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var9
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:186"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_291
#AT_START_292
at_fn_group_banner 292 'mat73_read_le.at:189' \
  "Read 2D 8-bit unsigned integer array" "           " 7
at_xfail=no
(
  $as_echo "292. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:190: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:190"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:190"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:204: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var10"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var10" "mat73_read_le.at:204"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var10
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var10
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:204"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_292
#AT_START_293
at_fn_group_banner 293 'mat73_read_le.at:207' \
  "Read 2D double-precision complex array" "         " 7
at_xfail=no
(
  $as_echo "293. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:208: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:208"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:208"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:222: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var11" "mat73_read_le.at:222"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:222"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_293
#AT_START_294
at_fn_group_banner 294 'mat73_read_le.at:225' \
  "Read 2D single-precision complex array" "         " 7
at_xfail=no
(
  $as_echo "294. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:226: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:226"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:226"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:240: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var12"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var12" "mat73_read_le.at:240"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var12
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var12
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:240"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_294
#AT_START_295
at_fn_group_banner 295 'mat73_read_le.at:243' \
  "Read 2D 64-bit integer complex array" "           " 7
at_xfail=no
(
  $as_echo "295. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:244: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:244"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:244"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:258: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var13"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var13" "mat73_read_le.at:258"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var13
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var13
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:258"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_295
#AT_START_296
at_fn_group_banner 296 'mat73_read_le.at:261' \
  "Read 2D 64-bit unsigned integer complex array" "  " 7
at_xfail=no
(
  $as_echo "296. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:262: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:262"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:262"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:276: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var14"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var14" "mat73_read_le.at:276"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var14
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var14
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:276"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_296
#AT_START_297
at_fn_group_banner 297 'mat73_read_le.at:279' \
  "Read 2D 32-bit integer complex array" "           " 7
at_xfail=no
(
  $as_echo "297. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:280: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:280"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:280"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:294: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var15"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var15" "mat73_read_le.at:294"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var15
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var15
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:294"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_297
#AT_START_298
at_fn_group_banner 298 'mat73_read_le.at:297' \
  "Read 2D 32-bit unsigned integer complex array" "  " 7
at_xfail=no
(
  $as_echo "298. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:298: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:298"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:298"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:312: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var16"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var16" "mat73_read_le.at:312"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var16
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var16
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:312"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_298
#AT_START_299
at_fn_group_banner 299 'mat73_read_le.at:315' \
  "Read 2D 16-bit integer complex array" "           " 7
at_xfail=no
(
  $as_echo "299. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:316: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:316"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:316"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:330: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var17"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var17" "mat73_read_le.at:330"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var17
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var17
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:330"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_299
#AT_START_300
at_fn_group_banner 300 'mat73_read_le.at:333' \
  "Read 2D 16-bit unsigned integer complex array" "  " 7
at_xfail=no
(
  $as_echo "300. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:334: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:334"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:334"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:348: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var18"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var18" "mat73_read_le.at:348"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var18
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var18
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:348"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_300
#AT_START_301
at_fn_group_banner 301 'mat73_read_le.at:351' \
  "Read 2D 8-bit integer complex array" "            " 7
at_xfail=no
(
  $as_echo "301. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:352: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:352"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:352"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:366: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var19"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var19" "mat73_read_le.at:366"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var19
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var19
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:366"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_301
#AT_START_302
at_fn_group_banner 302 'mat73_read_le.at:369' \
  "Read 2D 8-bit unsigned integer complex array" "   " 7
at_xfail=no
(
  $as_echo "302. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:370: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:370"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:370"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:384: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var20"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var20" "mat73_read_le.at:384"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var20
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var20
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:384"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_302
#AT_START_303
at_fn_group_banner 303 'mat73_read_le.at:387' \
  "Read double-precision sparse array" "             " 7
at_xfail=no
(
  $as_echo "303. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:388: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:388"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:388"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:403: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var21"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var21" "mat73_read_le.at:403"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var21
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var21
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,2)  2
    (3,3)  3
    (4,4)  4
    (5,5)  5
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:403"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_303
#AT_START_304
at_fn_group_banner 304 'mat73_read_le.at:406' \
  "Read double-precision sparse complex array" "     " 7
at_xfail=no
(
  $as_echo "304. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:407: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:407"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:407"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:422: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var22"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var22" "mat73_read_le.at:422"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var22
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var22
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 6i
    (2,2)  2 + 7i
    (3,3)  3 + 8i
    (4,4)  4 + 9i
    (5,5)  5 + 10i
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_304
#AT_START_305
at_fn_group_banner 305 'mat73_read_le.at:425' \
  "Read empty array" "                               " 7
at_xfail=no
(
  $as_echo "305. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:426: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:426"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:426"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:434: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var23"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var23" "mat73_read_le.at:434"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var23
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var23
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:434"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_305
#AT_START_306
at_fn_group_banner 306 'mat73_read_le.at:437' \
  "Read 2D character array" "                        " 7
at_xfail=no
(
  $as_echo "306. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:438: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:438"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:438"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:452: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var24" "mat73_read_le.at:452"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:452"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_306
#AT_START_307
at_fn_group_banner 307 'mat73_read_le.at:455' \
  "Read empty structure array" "                     " 7
at_xfail=no
(
  $as_echo "307. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:456: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:456"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:456"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:466: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var25"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var25" "mat73_read_le.at:466"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var25
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var25
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:466"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_307
#AT_START_308
at_fn_group_banner 308 'mat73_read_le.at:469' \
  "Read empty structure array with fields" "         " 7
at_xfail=no
(
  $as_echo "308. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:470: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:470"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:470"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:484: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var26"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var26" "mat73_read_le.at:484"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var26
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var26
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:484"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_308
#AT_START_309
at_fn_group_banner 309 'mat73_read_le.at:487' \
  "Read structure array with empty fields" "         " 7
at_xfail=no
(
  $as_echo "309. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:488: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:488"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:488"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:522: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var27"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var27" "mat73_read_le.at:522"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var27
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var27
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:522"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_309
#AT_START_310
at_fn_group_banner 310 'mat73_read_le.at:525' \
  "Read structure array with double-precision fields" "" 7
at_xfail=no
(
  $as_echo "310. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:526: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:526"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:526"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:572: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var28"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var28" "mat73_read_le.at:572"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var28
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var28
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:572"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_310
#AT_START_311
at_fn_group_banner 311 'mat73_read_le.at:575' \
  "Read structure array with single-precision fields" "" 7
at_xfail=no
(
  $as_echo "311. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:576: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:576"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:576"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:622: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var29"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var29" "mat73_read_le.at:622"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var29
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var29
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:622"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_311
#AT_START_312
at_fn_group_banner 312 'mat73_read_le.at:625' \
  "Read structure array with 64-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "312. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:626: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:626"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:626"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:672: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var30"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var30" "mat73_read_le.at:672"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var30
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var30
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:672"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_312
#AT_START_313
at_fn_group_banner 313 'mat73_read_le.at:675' \
  "Read structure array with 64-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "313. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:676: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:676"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:676"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:722: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var31"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var31" "mat73_read_le.at:722"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var31
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var31
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:722"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_313
#AT_START_314
at_fn_group_banner 314 'mat73_read_le.at:725' \
  "Read structure array with 32-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "314. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:726: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:726"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:726"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:772: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var32"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var32" "mat73_read_le.at:772"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var32
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var32
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:772"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_314
#AT_START_315
at_fn_group_banner 315 'mat73_read_le.at:775' \
  "Read structure array with 32-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "315. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:776: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:776"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:776"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:822: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var33"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var33" "mat73_read_le.at:822"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var33
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var33
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:822"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_315
#AT_START_316
at_fn_group_banner 316 'mat73_read_le.at:825' \
  "Read structure array with 16-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "316. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:826: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:826"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:826"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:872: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var34"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var34" "mat73_read_le.at:872"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var34
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var34
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:872"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_316
#AT_START_317
at_fn_group_banner 317 'mat73_read_le.at:875' \
  "Read structure array with 16-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "317. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:876: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:876"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:876"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:922: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var35"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var35" "mat73_read_le.at:922"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var35
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var35
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:922"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_317
#AT_START_318
at_fn_group_banner 318 'mat73_read_le.at:925' \
  "Read structure array with 8-bit integer fields" " " 7
at_xfail=no
(
  $as_echo "318. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:926: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:926"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:926"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:972: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var36"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var36" "mat73_read_le.at:972"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var36
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var36
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:972"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_318
#AT_START_319
at_fn_group_banner 319 'mat73_read_le.at:975' \
  "Read structure array with 8-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "319. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:976: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:976"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:976"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1022: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var37"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var37" "mat73_read_le.at:1022"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var37
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var37
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1022"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_319
#AT_START_320
at_fn_group_banner 320 'mat73_read_le.at:1025' \
  "Read structure array with complex double-precision fields" "" 7
at_xfail=no
(
  $as_echo "320. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1026: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1026"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1026"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1072: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var38"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var38" "mat73_read_le.at:1072"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var38
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var38
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1072"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_320
#AT_START_321
at_fn_group_banner 321 'mat73_read_le.at:1075' \
  "Read structure array with complex single-precision fields" "" 7
at_xfail=no
(
  $as_echo "321. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1076: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1076"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1076"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1122: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var39"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var39" "mat73_read_le.at:1122"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var39
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var39
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1122"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_321
#AT_START_322
at_fn_group_banner 322 'mat73_read_le.at:1125' \
  "Read structure array with complex 64-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "322. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1126: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1126"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1126"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1172: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var40"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var40" "mat73_read_le.at:1172"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var40
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var40
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1172"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_322
#AT_START_323
at_fn_group_banner 323 'mat73_read_le.at:1175' \
  "Read structure array with complex 64-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "323. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1176: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1176"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1176"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1222: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var41"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var41" "mat73_read_le.at:1222"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var41
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var41
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1222"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_323
#AT_START_324
at_fn_group_banner 324 'mat73_read_le.at:1225' \
  "Read structure array with complex 32-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "324. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1226: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1226"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1226"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1272: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var42"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var42" "mat73_read_le.at:1272"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var42
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var42
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1272"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_324
#AT_START_325
at_fn_group_banner 325 'mat73_read_le.at:1275' \
  "Read structure array with complex 32-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "325. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1276: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1276"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1276"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1322: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var43"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var43" "mat73_read_le.at:1322"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var43
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var43
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1322"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_325
#AT_START_326
at_fn_group_banner 326 'mat73_read_le.at:1325' \
  "Read structure array with complex 16-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "326. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1326: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1326"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1326"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1372: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var44"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var44" "mat73_read_le.at:1372"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var44
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var44
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1372"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_326
#AT_START_327
at_fn_group_banner 327 'mat73_read_le.at:1375' \
  "Read structure array with complex 16-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "327. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1376: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1376"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1376"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1422: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var45"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var45" "mat73_read_le.at:1422"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var45
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var45
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_327
#AT_START_328
at_fn_group_banner 328 'mat73_read_le.at:1425' \
  "Read structure array with complex 8-bit integer fields" "" 7
at_xfail=no
(
  $as_echo "328. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1426: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1426"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1426"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1472: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var46"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var46" "mat73_read_le.at:1472"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var46
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var46
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1472"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_328
#AT_START_329
at_fn_group_banner 329 'mat73_read_le.at:1475' \
  "Read structure array with complex 8-bit unsigned integer fields" "" 7
at_xfail=no
(
  $as_echo "329. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1476: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1476"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1476"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1522: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var47"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var47" "mat73_read_le.at:1522"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var47
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var47
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1522"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_329
#AT_START_330
at_fn_group_banner 330 'mat73_read_le.at:1525' \
  "Read structure array with double-precision sparse fields" "" 7
at_xfail=no
(
  $as_echo "330. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1526: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1526"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1526"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1578: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var48"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var48" "mat73_read_le.at:1578"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var48
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var48
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1578"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_330
#AT_START_331
at_fn_group_banner 331 'mat73_read_le.at:1581' \
  "Read structure array with complex double-precision sparse fields" "" 7
at_xfail=no
(
  $as_echo "331. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1582: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1582"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1582"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1634: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var49"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var49" "mat73_read_le.at:1634"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var49
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var49
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1634"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_331
#AT_START_332
at_fn_group_banner 332 'mat73_read_le.at:1637' \
  "Read structure array with character fields" "     " 7
at_xfail=no
(
  $as_echo "332. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1638: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1638"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1638"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1680: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var50"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var50" "mat73_read_le.at:1680"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var50
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var50
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1680"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_332
#AT_START_333
at_fn_group_banner 333 'mat73_read_le.at:1683' \
  "Read empty cell array" "                          " 7
at_xfail=no
(
  $as_echo "333. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1684: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1684"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1684"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1694: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var51"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var51" "mat73_read_le.at:1694"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var51
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var51
      Rank: 2
Dimensions: 0 x 0
Class Type: Cell Array
 Data Type: Cell Array
{
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1694"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_333
#AT_START_334
at_fn_group_banner 334 'mat73_read_le.at:1697' \
  "Read cell array with empty arrays" "              " 7
at_xfail=no
(
  $as_echo "334. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1698: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1698"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1698"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1748: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var52"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var52" "mat73_read_le.at:1748"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var52
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var52
      Rank: 2
Dimensions: 1 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Rank: 2
Dimensions: 0 x 0
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1748"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_334
#AT_START_335
at_fn_group_banner 335 'mat73_read_le.at:1751' \
  "Read cell array with double-precision arrays" "   " 7
at_xfail=no
(
  $as_echo "335. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1752: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1752"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1752"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1813: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var53"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var53" "mat73_read_le.at:1813"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var53
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var53
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1813"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_335
#AT_START_336
at_fn_group_banner 336 'mat73_read_le.at:1816' \
  "Read cell array with single-precision arrays" "   " 7
at_xfail=no
(
  $as_echo "336. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1817: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1817"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1817"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1878: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var54"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var54" "mat73_read_le.at:1878"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var54
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var54
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1878"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_336
#AT_START_337
at_fn_group_banner 337 'mat73_read_le.at:1881' \
  "Read cell array with 64-bit integer arrays" "     " 7
at_xfail=no
(
  $as_echo "337. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1882: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1882"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1882"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1943: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var55"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var55" "mat73_read_le.at:1943"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var55
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var55
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1943"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_337
#AT_START_338
at_fn_group_banner 338 'mat73_read_le.at:1946' \
  "Read cell array with 64-bit unsigned integer arrays" "" 7
at_xfail=no
(
  $as_echo "338. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:1947: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:1947"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:1947"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2008: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var56"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var56" "mat73_read_le.at:2008"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var56
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var56
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2008"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_338
#AT_START_339
at_fn_group_banner 339 'mat73_read_le.at:2011' \
  "Read cell array with 32-bit integer arrays" "     " 7
at_xfail=no
(
  $as_echo "339. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2012: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2012"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2012"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2073: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var57"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var57" "mat73_read_le.at:2073"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var57
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var57
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2073"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_339
#AT_START_340
at_fn_group_banner 340 'mat73_read_le.at:2076' \
  "Read cell array with 32-bit unsigned integer arrays" "" 7
at_xfail=no
(
  $as_echo "340. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2077: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2077"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2077"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2138: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var58"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var58" "mat73_read_le.at:2138"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var58
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var58
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2138"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_340
#AT_START_341
at_fn_group_banner 341 'mat73_read_le.at:2141' \
  "Read cell array with 16-bit integer arrays" "     " 7
at_xfail=no
(
  $as_echo "341. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2142: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2142"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2142"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2203: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var59"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var59" "mat73_read_le.at:2203"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var59
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var59
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2203"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_341
#AT_START_342
at_fn_group_banner 342 'mat73_read_le.at:2206' \
  "Read cell array with 16-bit unsigned integer arrays" "" 7
at_xfail=no
(
  $as_echo "342. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2207: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2207"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2207"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2268: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var60"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var60" "mat73_read_le.at:2268"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var60
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var60
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2268"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_342
#AT_START_343
at_fn_group_banner 343 'mat73_read_le.at:2271' \
  "Read cell array with 8-bit integer arrays" "      " 7
at_xfail=no
(
  $as_echo "343. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2272: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2272"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2272"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2333: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var61"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var61" "mat73_read_le.at:2333"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var61
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var61
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2333"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_343
#AT_START_344
at_fn_group_banner 344 'mat73_read_le.at:2336' \
  "Read cell array with 8-bit unsigned integer arrays" "" 7
at_xfail=no
(
  $as_echo "344. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2337: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2337"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2337"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2398: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var62"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var62" "mat73_read_le.at:2398"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var62
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var62
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2398"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_344
#AT_START_345
at_fn_group_banner 345 'mat73_read_le.at:2401' \
  "Read cell array with double-precision sparse arrays" "" 7
at_xfail=no
(
  $as_echo "345. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2402: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2402"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2402"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2452: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var63"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var63" "mat73_read_le.at:2452"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var63
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var63
      Rank: 2
Dimensions: 1 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2452"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_345
#AT_START_346
at_fn_group_banner 346 'mat73_read_le.at:2455' \
  "Read cell array with complex double-precision sparse arrays" "" 7
at_xfail=no
(
  $as_echo "346. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2456: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2456"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2456"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2506: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var64"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var64" "mat73_read_le.at:2506"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var64
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var64
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2506"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_346
#AT_START_347
at_fn_group_banner 347 'mat73_read_le.at:2509' \
  "Read cell array with character arrays" "          " 7
at_xfail=no
(
  $as_echo "347. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2510: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2510"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2510"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2548: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var65"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var65" "mat73_read_le.at:2548"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var65
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var65
      Rank: 2
Dimensions: 2 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2548"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_347
#AT_START_348
at_fn_group_banner 348 'mat73_read_le.at:2551' \
  "Read cell array with empty structure arrays" "    " 7
at_xfail=no
(
  $as_echo "348. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2552: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2552"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2552"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2608: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var66"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var66" "mat73_read_le.at:2608"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var66
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var66
      Rank: 2
Dimensions: 1 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2608"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_348
#AT_START_349
at_fn_group_banner 349 'mat73_read_le.at:2611' \
  "Read cell array with structure arrays (numeric fields)" "" 7
at_xfail=no
(
  $as_echo "349. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:2612: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:2612"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:2612"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:3462: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var67"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var67" "mat73_read_le.at:3462"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var67
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var67
      Rank: 2
Dimensions: 2 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:3462"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_349
#AT_START_350
at_fn_group_banner 350 'mat73_read_le.at:3465' \
  "Read cell array with structure arrays (sparse fields)" "" 7
at_xfail=no
(
  $as_echo "350. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:3466: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:3466"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:3466"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:3572: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var68"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var68" "mat73_read_le.at:3572"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var68
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var68
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:3572"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_350
#AT_START_351
at_fn_group_banner 351 'mat73_read_le.at:3575' \
  "Read cell array structure arrays (character fields)" "" 7
at_xfail=no
(
  $as_echo "351. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:3576: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_le.at:3576"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:3576"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_le.at:3630: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_le.mat var69"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var69" "mat73_read_le.at:3630"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_le.mat var69
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var69
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_le.at:3630"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_351
#AT_START_352
at_fn_group_banner 352 'mat73_read_be.at:27' \
  "Read 2D double-precision array" "                 " 8
at_xfail=no
(
  $as_echo "352. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:28: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:28"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:28"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:42: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var1" "mat73_read_be.at:42"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var1
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:42"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_352
#AT_START_353
at_fn_group_banner 353 'mat73_read_be.at:45' \
  "Read 2D single-precision array" "                 " 8
at_xfail=no
(
  $as_echo "353. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:46: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:46"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:46"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:60: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var2" "mat73_read_be.at:60"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var2
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:60"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_353
#AT_START_354
at_fn_group_banner 354 'mat73_read_be.at:63' \
  "Read 2D 64-bit integer array" "                   " 8
at_xfail=no
(
  $as_echo "354. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:64: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:64"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:64"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:78: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var3" "mat73_read_be.at:78"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var3
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:78"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_354
#AT_START_355
at_fn_group_banner 355 'mat73_read_be.at:81' \
  "Read 2D 64-bit unsigned integer array" "          " 8
at_xfail=no
(
  $as_echo "355. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:82: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:82"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:82"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:96: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var4" "mat73_read_be.at:96"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var4
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:96"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_355
#AT_START_356
at_fn_group_banner 356 'mat73_read_be.at:99' \
  "Read 2D 32-bit integer array" "                   " 8
at_xfail=no
(
  $as_echo "356. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:100: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:100"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:100"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:114: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var5"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var5" "mat73_read_be.at:114"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var5
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var5
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:114"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_356
#AT_START_357
at_fn_group_banner 357 'mat73_read_be.at:117' \
  "Read 2D 32-bit unsigned integer array" "          " 8
at_xfail=no
(
  $as_echo "357. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:118: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:118"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:118"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:132: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var6"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var6" "mat73_read_be.at:132"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var6
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var6
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:132"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_357
#AT_START_358
at_fn_group_banner 358 'mat73_read_be.at:135' \
  "Read 2D 16-bit integer array" "                   " 8
at_xfail=no
(
  $as_echo "358. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:136: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:136"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:136"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:150: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var7"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var7" "mat73_read_be.at:150"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var7
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var7
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:150"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_358
#AT_START_359
at_fn_group_banner 359 'mat73_read_be.at:153' \
  "Read 2D 16-bit unsigned integer array" "          " 8
at_xfail=no
(
  $as_echo "359. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:154: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:154"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:154"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:168: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var8"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var8" "mat73_read_be.at:168"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var8
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var8
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:168"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_359
#AT_START_360
at_fn_group_banner 360 'mat73_read_be.at:171' \
  "Read 2D 8-bit integer array" "                    " 8
at_xfail=no
(
  $as_echo "360. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:172: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:172"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:172"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:186: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var9"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var9" "mat73_read_be.at:186"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var9
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var9
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:186"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_360
#AT_START_361
at_fn_group_banner 361 'mat73_read_be.at:189' \
  "Read 2D 8-bit unsigned integer array" "           " 8
at_xfail=no
(
  $as_echo "361. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:190: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:190"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:190"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:204: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var10"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var10" "mat73_read_be.at:204"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var10
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var10
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 5 9 13 17 
2 6 10 14 18 
3 7 11 15 19 
4 8 12 16 20 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:204"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_361
#AT_START_362
at_fn_group_banner 362 'mat73_read_be.at:207' \
  "Read 2D double-precision complex array" "         " 8
at_xfail=no
(
  $as_echo "362. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:208: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:208"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:208"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:222: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var11"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var11" "mat73_read_be.at:222"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var11
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var11
      Rank: 2
Dimensions: 4 x 5
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:222"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_362
#AT_START_363
at_fn_group_banner 363 'mat73_read_be.at:225' \
  "Read 2D single-precision complex array" "         " 8
at_xfail=no
(
  $as_echo "363. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:226: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:226"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:226"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:240: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var12"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var12" "mat73_read_be.at:240"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var12
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var12
      Rank: 2
Dimensions: 4 x 5
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:240"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_363
#AT_START_364
at_fn_group_banner 364 'mat73_read_be.at:243' \
  "Read 2D 64-bit integer complex array" "           " 8
at_xfail=no
(
  $as_echo "364. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:244: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:244"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:244"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:258: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var13"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var13" "mat73_read_be.at:258"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var13
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var13
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:258"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_364
#AT_START_365
at_fn_group_banner 365 'mat73_read_be.at:261' \
  "Read 2D 64-bit unsigned integer complex array" "  " 8
at_xfail=no
(
  $as_echo "365. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:262: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:262"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:262"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:276: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var14"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var14" "mat73_read_be.at:276"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var14
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var14
      Rank: 2
Dimensions: 4 x 5
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:276"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_365
#AT_START_366
at_fn_group_banner 366 'mat73_read_be.at:279' \
  "Read 2D 32-bit integer complex array" "           " 8
at_xfail=no
(
  $as_echo "366. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:280: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:280"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:280"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:294: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var15"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var15" "mat73_read_be.at:294"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var15
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var15
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:294"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_366
#AT_START_367
at_fn_group_banner 367 'mat73_read_be.at:297' \
  "Read 2D 32-bit unsigned integer complex array" "  " 8
at_xfail=no
(
  $as_echo "367. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:298: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:298"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:298"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:312: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var16"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var16" "mat73_read_be.at:312"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var16
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var16
      Rank: 2
Dimensions: 4 x 5
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:312"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_367
#AT_START_368
at_fn_group_banner 368 'mat73_read_be.at:315' \
  "Read 2D 16-bit integer complex array" "           " 8
at_xfail=no
(
  $as_echo "368. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:316: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:316"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:316"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:330: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var17"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var17" "mat73_read_be.at:330"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var17
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var17
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:330"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_368
#AT_START_369
at_fn_group_banner 369 'mat73_read_be.at:333' \
  "Read 2D 16-bit unsigned integer complex array" "  " 8
at_xfail=no
(
  $as_echo "369. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:334: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:334"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:334"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:348: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var18"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var18" "mat73_read_be.at:348"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var18
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var18
      Rank: 2
Dimensions: 4 x 5
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:348"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_369
#AT_START_370
at_fn_group_banner 370 'mat73_read_be.at:351' \
  "Read 2D 8-bit integer complex array" "            " 8
at_xfail=no
(
  $as_echo "370. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:352: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:352"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:352"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:366: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var19"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var19" "mat73_read_be.at:366"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var19
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var19
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:366"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_370
#AT_START_371
at_fn_group_banner 371 'mat73_read_be.at:369' \
  "Read 2D 8-bit unsigned integer complex array" "   " 8
at_xfail=no
(
  $as_echo "371. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:370: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:370"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:370"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:384: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var20"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var20" "mat73_read_be.at:384"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var20
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var20
      Rank: 2
Dimensions: 4 x 5
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 21i 5 + 25i 9 + 29i 13 + 33i 17 + 37i 
2 + 22i 6 + 26i 10 + 30i 14 + 34i 18 + 38i 
3 + 23i 7 + 27i 11 + 31i 15 + 35i 19 + 39i 
4 + 24i 8 + 28i 12 + 32i 16 + 36i 20 + 40i 
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:384"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_371
#AT_START_372
at_fn_group_banner 372 'mat73_read_be.at:387' \
  "Read double-precision sparse array" "             " 8
at_xfail=no
(
  $as_echo "372. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:388: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:388"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:388"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:403: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var21"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var21" "mat73_read_be.at:403"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var21
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var21
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,2)  2
    (3,3)  3
    (4,4)  4
    (5,5)  5
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:403"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_372
#AT_START_373
at_fn_group_banner 373 'mat73_read_be.at:406' \
  "Read double-precision sparse complex array" "     " 8
at_xfail=no
(
  $as_echo "373. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:407: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:407"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:407"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:422: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var22"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var22" "mat73_read_be.at:422"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var22
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var22
      Rank: 2
Dimensions: 5 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 6i
    (2,2)  2 + 7i
    (3,3)  3 + 8i
    (4,4)  4 + 9i
    (5,5)  5 + 10i
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_373
#AT_START_374
at_fn_group_banner 374 'mat73_read_be.at:425' \
  "Read empty array" "                               " 8
at_xfail=no
(
  $as_echo "374. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:426: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:426"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:426"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:434: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var23"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var23" "mat73_read_be.at:434"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var23
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var23
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:434"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_374
#AT_START_375
at_fn_group_banner 375 'mat73_read_be.at:437' \
  "Read 2D character array" "                        " 8
at_xfail=no
(
  $as_echo "375. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:438: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:438"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:438"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:452: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var24"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var24" "mat73_read_be.at:452"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var24
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var24
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#\$%^&*()-_=+\`~
[{]}\\|;:'\",<.>/?          
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:452"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_375
#AT_START_376
at_fn_group_banner 376 'mat73_read_be.at:455' \
  "Read empty structure array" "                     " 8
at_xfail=no
(
  $as_echo "376. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:456: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:456"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:456"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:466: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var25"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var25" "mat73_read_be.at:466"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var25
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var25
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:466"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_376
#AT_START_377
at_fn_group_banner 377 'mat73_read_be.at:468' \
  "Read empty structure array with fields" "         " 8
at_xfail=no
(
  $as_echo "377. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:469: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:469"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:469"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:483: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var26"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var26" "mat73_read_be.at:483"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var26
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var26
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:483"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_377
#AT_START_378
at_fn_group_banner 378 'mat73_read_be.at:485' \
  "Read structure array with empty fields" "         " 8
at_xfail=no
(
  $as_echo "378. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:486: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:486"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:486"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:520: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var27"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var27" "mat73_read_be.at:520"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var27
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var27
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:520"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_378
#AT_START_379
at_fn_group_banner 379 'mat73_read_be.at:522' \
  "Read structure array with double-precision fields" "" 8
at_xfail=no
(
  $as_echo "379. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:523: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:523"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:523"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:569: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var28"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var28" "mat73_read_be.at:569"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var28
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var28
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:569"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_379
#AT_START_380
at_fn_group_banner 380 'mat73_read_be.at:571' \
  "Read structure array with single-precision fields" "" 8
at_xfail=no
(
  $as_echo "380. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:572: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:572"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:572"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:618: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var29"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var29" "mat73_read_be.at:618"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var29
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var29
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:618"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_380
#AT_START_381
at_fn_group_banner 381 'mat73_read_be.at:620' \
  "Read structure array with 64-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "381. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:621: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:621"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:621"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:667: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var30"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var30" "mat73_read_be.at:667"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var30
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var30
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:667"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_381
#AT_START_382
at_fn_group_banner 382 'mat73_read_be.at:669' \
  "Read structure array with 64-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "382. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:670: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:670"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:670"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:716: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var31"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var31" "mat73_read_be.at:716"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var31
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var31
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:716"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_382
#AT_START_383
at_fn_group_banner 383 'mat73_read_be.at:718' \
  "Read structure array with 32-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "383. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:719: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:719"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:719"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:765: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var32"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var32" "mat73_read_be.at:765"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var32
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var32
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:765"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_383
#AT_START_384
at_fn_group_banner 384 'mat73_read_be.at:767' \
  "Read structure array with 32-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "384. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:768: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:768"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:768"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:814: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var33"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var33" "mat73_read_be.at:814"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var33
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var33
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:814"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_384
#AT_START_385
at_fn_group_banner 385 'mat73_read_be.at:816' \
  "Read structure array with 16-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "385. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:817: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:817"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:817"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:863: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var34"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var34" "mat73_read_be.at:863"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var34
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var34
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:863"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_385
#AT_START_386
at_fn_group_banner 386 'mat73_read_be.at:865' \
  "Read structure array with 16-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "386. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:866: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:866"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:866"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:912: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var35"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var35" "mat73_read_be.at:912"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var35
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var35
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:912"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_386
#AT_START_387
at_fn_group_banner 387 'mat73_read_be.at:914' \
  "Read structure array with 8-bit integer fields" " " 8
at_xfail=no
(
  $as_echo "387. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:915: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:915"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:915"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:961: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var36"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var36" "mat73_read_be.at:961"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var36
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var36
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:961"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_387
#AT_START_388
at_fn_group_banner 388 'mat73_read_be.at:963' \
  "Read structure array with 8-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "388. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:964: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:964"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:964"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1010: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var37"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var37" "mat73_read_be.at:1010"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var37
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var37
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1010"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_388
#AT_START_389
at_fn_group_banner 389 'mat73_read_be.at:1012' \
  "Read structure array with complex double-precision fields" "" 8
at_xfail=no
(
  $as_echo "389. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1013: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1013"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1013"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1059: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var38"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var38" "mat73_read_be.at:1059"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var38
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var38
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1059"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_389
#AT_START_390
at_fn_group_banner 390 'mat73_read_be.at:1061' \
  "Read structure array with complex single-precision fields" "" 8
at_xfail=no
(
  $as_echo "390. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1062: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1062"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1062"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1108: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var39"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var39" "mat73_read_be.at:1108"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var39
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var39
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1108"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_390
#AT_START_391
at_fn_group_banner 391 'mat73_read_be.at:1110' \
  "Read structure array with complex 64-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "391. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1111: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1111"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1111"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1157: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var40"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var40" "mat73_read_be.at:1157"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var40
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var40
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1157"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_391
#AT_START_392
at_fn_group_banner 392 'mat73_read_be.at:1159' \
  "Read structure array with complex 64-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "392. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1160: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1160"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1160"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1206: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var41"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var41" "mat73_read_be.at:1206"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var41
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var41
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1206"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_392
#AT_START_393
at_fn_group_banner 393 'mat73_read_be.at:1208' \
  "Read structure array with complex 32-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "393. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1209: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1209"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1209"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1255: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var42"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var42" "mat73_read_be.at:1255"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var42
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var42
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1255"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_393
#AT_START_394
at_fn_group_banner 394 'mat73_read_be.at:1257' \
  "Read structure array with complex 32-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "394. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1258: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1258"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1258"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1304: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var43"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var43" "mat73_read_be.at:1304"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var43
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var43
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1304"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_394
#AT_START_395
at_fn_group_banner 395 'mat73_read_be.at:1306' \
  "Read structure array with complex 16-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "395. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1307: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1307"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1307"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1353: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var44"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var44" "mat73_read_be.at:1353"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var44
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var44
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1353"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_395
#AT_START_396
at_fn_group_banner 396 'mat73_read_be.at:1355' \
  "Read structure array with complex 16-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "396. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1356: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1356"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1356"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1402: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var45"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var45" "mat73_read_be.at:1402"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var45
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var45
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1402"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_396
#AT_START_397
at_fn_group_banner 397 'mat73_read_be.at:1404' \
  "Read structure array with complex 8-bit integer fields" "" 8
at_xfail=no
(
  $as_echo "397. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1405: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1405"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1405"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1451: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var46"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var46" "mat73_read_be.at:1451"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var46
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var46
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1451"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_397
#AT_START_398
at_fn_group_banner 398 'mat73_read_be.at:1453' \
  "Read structure array with complex 8-bit unsigned integer fields" "" 8
at_xfail=no
(
  $as_echo "398. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1454: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1454"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1454"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1500: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var47"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var47" "mat73_read_be.at:1500"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var47
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var47
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1500"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_398
#AT_START_399
at_fn_group_banner 399 'mat73_read_be.at:1503' \
  "Read structure array with double-precision sparse fields" "" 8
at_xfail=no
(
  $as_echo "399. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1504: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1504"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1504"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1556: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var48"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var48" "mat73_read_be.at:1556"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var48
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var48
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1556"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_399
#AT_START_400
at_fn_group_banner 400 'mat73_read_be.at:1559' \
  "Read structure array with complex double-precision sparse fields" "" 8
at_xfail=no
(
  $as_echo "400. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1560: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1560"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1560"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1612: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var49"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var49" "mat73_read_be.at:1612"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var49
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var49
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1612"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_400
#AT_START_401
at_fn_group_banner 401 'mat73_read_be.at:1615' \
  "Read structure array with character fields" "     " 8
at_xfail=no
(
  $as_echo "401. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1616: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1616"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1616"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1658: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var50"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var50" "mat73_read_be.at:1658"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var50
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var50
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1658"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_401
#AT_START_402
at_fn_group_banner 402 'mat73_read_be.at:1661' \
  "Read cell array with empty arrays" "              " 8
at_xfail=no
(
  $as_echo "402. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1662: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1662"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1662"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1712: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var52"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var52" "mat73_read_be.at:1712"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var52
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var52
      Rank: 2
Dimensions: 1 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 0
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Rank: 2
Dimensions: 0 x 0
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
      Rank: 2
Dimensions: 0 x 0
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1712"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_402
#AT_START_403
at_fn_group_banner 403 'mat73_read_be.at:1715' \
  "Read cell array with double-precision arrays" "   " 8
at_xfail=no
(
  $as_echo "403. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1716: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1716"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1716"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1777: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var53"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var53" "mat73_read_be.at:1777"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var53
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var53
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1777"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_403
#AT_START_404
at_fn_group_banner 404 'mat73_read_be.at:1780' \
  "Read cell array with single-precision arrays" "   " 8
at_xfail=no
(
  $as_echo "404. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1781: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1781"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1781"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1842: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var54"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var54" "mat73_read_be.at:1842"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var54
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var54
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1842"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_404
#AT_START_405
at_fn_group_banner 405 'mat73_read_be.at:1845' \
  "Read cell array with 64-bit integer arrays" "     " 8
at_xfail=no
(
  $as_echo "405. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1846: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1846"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1846"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1907: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var55"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var55" "mat73_read_be.at:1907"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var55
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var55
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1907"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_405
#AT_START_406
at_fn_group_banner 406 'mat73_read_be.at:1910' \
  "Read cell array with 64-bit unsigned integer arrays" "" 8
at_xfail=no
(
  $as_echo "406. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1911: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1911"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1911"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1972: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var56"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var56" "mat73_read_be.at:1972"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var56
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var56
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1972"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_406
#AT_START_407
at_fn_group_banner 407 'mat73_read_be.at:1975' \
  "Read cell array with 32-bit integer arrays" "     " 8
at_xfail=no
(
  $as_echo "407. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:1976: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:1976"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:1976"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2037: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var57"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var57" "mat73_read_be.at:2037"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var57
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var57
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2037"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_407
#AT_START_408
at_fn_group_banner 408 'mat73_read_be.at:2040' \
  "Read cell array with 32-bit unsigned integer arrays" "" 8
at_xfail=no
(
  $as_echo "408. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2041: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2041"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2041"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2102: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var58"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var58" "mat73_read_be.at:2102"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var58
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var58
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2102"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_408
#AT_START_409
at_fn_group_banner 409 'mat73_read_be.at:2105' \
  "Read cell array with 16-bit integer arrays" "     " 8
at_xfail=no
(
  $as_echo "409. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2106: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2106"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2106"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2167: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var59"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var59" "mat73_read_be.at:2167"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var59
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var59
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2167"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_409
#AT_START_410
at_fn_group_banner 410 'mat73_read_be.at:2170' \
  "Read cell array with 16-bit unsigned integer arrays" "" 8
at_xfail=no
(
  $as_echo "410. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2171: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2171"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2171"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2232: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var60"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var60" "mat73_read_be.at:2232"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var60
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var60
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2232"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_410
#AT_START_411
at_fn_group_banner 411 'mat73_read_be.at:2235' \
  "Read cell array with 8-bit integer arrays" "      " 8
at_xfail=no
(
  $as_echo "411. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2236: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2236"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2236"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2297: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var61"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var61" "mat73_read_be.at:2297"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var61
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var61
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2297"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_411
#AT_START_412
at_fn_group_banner 412 'mat73_read_be.at:2300' \
  "Read cell array with 8-bit unsigned integer arrays" "" 8
at_xfail=no
(
  $as_echo "412. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2301: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2301"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2301"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2362: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var62"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var62" "mat73_read_be.at:2362"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var62
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var62
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 2 
3 4 
}
      Rank: 2
Dimensions: 2 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
19 20 
21 22 
}
      Rank: 2
Dimensions: 2 x 3
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
5 6 7 
8 9 10 
}
      Rank: 2
Dimensions: 3 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
23 24 
25 26 
27 28 
}
      Rank: 2
Dimensions: 2 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
11 12 13 14 
15 16 17 18 
}
      Rank: 2
Dimensions: 4 x 2
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
29 30 
31 32 
33 34 
35 36 
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2362"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_412
#AT_START_413
at_fn_group_banner 413 'mat73_read_be.at:2365' \
  "Read cell array with double-precision sparse arrays" "" 8
at_xfail=no
(
  $as_echo "413. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2366: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2366"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2366"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2416: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var63"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var63" "mat73_read_be.at:2416"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var63
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var63
      Rank: 2
Dimensions: 1 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2416"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_413
#AT_START_414
at_fn_group_banner 414 'mat73_read_be.at:2419' \
  "Read cell array with complex double-precision sparse arrays" "" 8
at_xfail=no
(
  $as_echo "414. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2420: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2420"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2420"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2470: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var64"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var64" "mat73_read_be.at:2470"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var64
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var64
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2470"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_414
#AT_START_415
at_fn_group_banner 415 'mat73_read_be.at:2473' \
  "Read cell array with character arrays" "          " 8
at_xfail=no
(
  $as_echo "415. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2474: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2474"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2474"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2512: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var65"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var65" "mat73_read_be.at:2512"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var65
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var65
      Rank: 2
Dimensions: 2 x 2
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2512"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_415
#AT_START_416
at_fn_group_banner 416 'mat73_read_be.at:2515' \
  "Read cell array with empty structure arrays" "    " 8
at_xfail=no
(
  $as_echo "416. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2516: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2516"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2516"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2572: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var66"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var66" "mat73_read_be.at:2572"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var66
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var66
      Rank: 2
Dimensions: 1 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Rank: 2
Dimensions: 1 x 2
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2572"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_416
#AT_START_417
at_fn_group_banner 417 'mat73_read_be.at:2575' \
  "Read cell array with structure arrays (numeric fields)" "" 8
at_xfail=no
(
  $as_echo "417. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:2576: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:2576"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:2576"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:3426: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var67"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var67" "mat73_read_be.at:3426"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var67
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var67
      Rank: 2
Dimensions: 2 x 10
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
2 5 8 11 
3 6 9 12 
4 7 10 13 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
14 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
15 18 21 24 
16 19 22 25 
17 20 23 26 
}
}
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
4 + 54i 7 + 57i 10 + 60i 13 + 63i 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 1
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
14 + 64i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
16 + 66i 19 + 69i 22 + 72i 25 + 75i 
17 + 67i 20 + 70i 23 + 73i 26 + 76i 
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:3426"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_417
#AT_START_418
at_fn_group_banner 418 'mat73_read_be.at:3429' \
  "Read cell array with structure arrays (sparse fields)" "" 8
at_xfail=no
(
  $as_echo "418. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:3430: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:3430"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:3430"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:3536: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var68"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var68" "mat73_read_be.at:3536"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var68
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var68
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (1,2)  5
    (2,2)  6
    (1,3)  9
    (2,3)  10
    (3,3)  11
    (1,4)  13
    (2,4)  14
    (3,4)  15
    (4,4)  16
    (1,5)  17
    (2,5)  18
    (3,5)  19
    (4,5)  20
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (2,1)  5
    (3,1)  9
    (4,1)  13
    (5,1)  17
    (2,2)  6
    (3,2)  10
    (4,2)  14
    (5,2)  18
    (3,3)  11
    (4,3)  15
    (5,3)  19
    (4,4)  16
    (5,4)  20
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 4 x 5
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 21i
    (1,2)  5 + 25i
    (2,2)  6 + 26i
    (1,3)  9 + 29i
    (2,3)  10 + 30i
    (3,3)  11 + 31i
    (1,4)  13 + 33i
    (2,4)  14 + 34i
    (3,4)  15 + 35i
    (4,4)  16 + 36i
    (1,5)  17 + 37i
    (2,5)  18 + 38i
    (3,5)  19 + 39i
    (4,5)  20 + 40i
}
      Name: field2
      Rank: 2
Dimensions: 5 x 4
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + -21i
    (2,1)  5 + -25i
    (3,1)  9 + -29i
    (4,1)  13 + -33i
    (5,1)  17 + -37i
    (2,2)  6 + -26i
    (3,2)  10 + -30i
    (4,2)  14 + -34i
    (5,2)  18 + -38i
    (3,3)  11 + -31i
    (4,3)  15 + -35i
    (5,3)  19 + -39i
    (4,4)  16 + -36i
    (5,4)  20 + -40i
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:3536"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_418
#AT_START_419
at_fn_group_banner 419 'mat73_read_be.at:3539' \
  "Read cell array structure arrays (character fields)" "" 8
at_xfail=no
(
  $as_echo "419. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:3540: if test \$MAT73 -ne 1;then exit 77;fi"
at_fn_check_prepare_dynamic "if test $MAT73 -ne 1;then exit 77;fi" "mat73_read_be.at:3540"
( $at_check_trace; if test $MAT73 -ne 1;then exit 77;fi
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
at_fn_diff_devnull "$at_stderr" || at_failed=:
at_fn_diff_devnull "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:3540"
$at_failed && at_fn_log_failure
$at_traceon; }

{ set +x
$as_echo "$at_srcdir/mat73_read_be.at:3594: \$builddir/test_mat readvar \$srcdir/datasets/matio_test_cases_hdf_be.mat var69"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var69" "mat73_read_be.at:3594"
( $at_check_trace; $builddir/test_mat readvar $srcdir/datasets/matio_test_cases_hdf_be.mat var69
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "      Name: var69
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
1234567890!@#\$%^&*()-_=+\`~
}
      Name: field2
      Rank: 2
Dimensions: 1 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
[{]}\\|;:'\",<.>/?          
}
}
}
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_read_be.at:3594"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_419
#AT_START_420
at_fn_group_banner 420 'mat5_uncompressed_write.at:27' \
  "Write 2D double-precision array" "                " 9
at_xfail=no
(
  $as_echo "420. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:29: \$builddir/test_mat -v 5 -c double write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c double write_2d_numeric" "mat5_uncompressed_write.at:29"
( $at_check_trace; $builddir/test_mat -v 5 -c double write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:29"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:45: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:45"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:45"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:46" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:46"
cat >test_write_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:66: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:66"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:66"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_420
#AT_START_421
at_fn_group_banner 421 'mat5_uncompressed_write.at:69' \
  "Write 2D single-precision array" "                " 9
at_xfail=no
(
  $as_echo "421. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:71: \$builddir/test_mat -v 5 -c single write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c single write_2d_numeric" "mat5_uncompressed_write.at:71"
( $at_check_trace; $builddir/test_mat -v 5 -c single write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:71"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:87: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:87"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:87"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:88" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:88"
cat >test_write_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = single(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:108: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:108"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:108"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_421
#AT_START_422
at_fn_group_banner 422 'mat5_uncompressed_write.at:111' \
  "Write 2D 64-bit integer array" "                  " 9
at_xfail=no
(
  $as_echo "422. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:112" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:112"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:114: \$builddir/test_mat -v 5 -c int64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int64 write_2d_numeric" "mat5_uncompressed_write.at:114"
( $at_check_trace; $builddir/test_mat -v 5 -c int64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:114"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:130: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:130"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:130"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:131" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:131"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:151: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:151"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:151"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_422
#AT_START_423
at_fn_group_banner 423 'mat5_uncompressed_write.at:154' \
  "Write 2D 64-bit unsigned integer array" "         " 9
at_xfail=no
(
  $as_echo "423. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:155" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:155"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:157: \$builddir/test_mat -v 5 -c uint64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint64 write_2d_numeric" "mat5_uncompressed_write.at:157"
( $at_check_trace; $builddir/test_mat -v 5 -c uint64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:157"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:173: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:173"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:173"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:174" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:174"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:194: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:194"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:194"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_423
#AT_START_424
at_fn_group_banner 424 'mat5_uncompressed_write.at:197' \
  "Write 2D 32-bit integer array" "                  " 9
at_xfail=no
(
  $as_echo "424. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:199: \$builddir/test_mat -v 5 -c int32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int32 write_2d_numeric" "mat5_uncompressed_write.at:199"
( $at_check_trace; $builddir/test_mat -v 5 -c int32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:199"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:215: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:215"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:215"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:216" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:216"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:236: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:236"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:236"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_424
#AT_START_425
at_fn_group_banner 425 'mat5_uncompressed_write.at:239' \
  "Write 2D 32-bit unsigned integer array" "         " 9
at_xfail=no
(
  $as_echo "425. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:241: \$builddir/test_mat -v 5 -c uint32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint32 write_2d_numeric" "mat5_uncompressed_write.at:241"
( $at_check_trace; $builddir/test_mat -v 5 -c uint32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:241"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:257: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:257"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:257"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:258" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:258"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:278: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:278"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:278"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_425
#AT_START_426
at_fn_group_banner 426 'mat5_uncompressed_write.at:281' \
  "Write 2D 16-bit integer array" "                  " 9
at_xfail=no
(
  $as_echo "426. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:283: \$builddir/test_mat -v 5 -c int16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int16 write_2d_numeric" "mat5_uncompressed_write.at:283"
( $at_check_trace; $builddir/test_mat -v 5 -c int16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:283"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:299: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:299"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:299"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:300" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:300"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:320: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:320"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:320"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_426
#AT_START_427
at_fn_group_banner 427 'mat5_uncompressed_write.at:323' \
  "Write 2D 16-bit unsigned integer array" "         " 9
at_xfail=no
(
  $as_echo "427. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:325: \$builddir/test_mat -v 5 -c uint16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint16 write_2d_numeric" "mat5_uncompressed_write.at:325"
( $at_check_trace; $builddir/test_mat -v 5 -c uint16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:325"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:341: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:341"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:341"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:342" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:342"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:362: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:362"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:362"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_427
#AT_START_428
at_fn_group_banner 428 'mat5_uncompressed_write.at:365' \
  "Write 2D 8-bit integer array" "                   " 9
at_xfail=no
(
  $as_echo "428. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:367: \$builddir/test_mat -v 5 -c int8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int8 write_2d_numeric" "mat5_uncompressed_write.at:367"
( $at_check_trace; $builddir/test_mat -v 5 -c int8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:367"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:383: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:383"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:383"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:384" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:384"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:404: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:404"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:404"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_428
#AT_START_429
at_fn_group_banner 429 'mat5_uncompressed_write.at:407' \
  "Write 2D 8-bit unsigned integer array" "          " 9
at_xfail=no
(
  $as_echo "429. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:409: \$builddir/test_mat -v 5 -c uint8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint8 write_2d_numeric" "mat5_uncompressed_write.at:409"
( $at_check_trace; $builddir/test_mat -v 5 -c uint8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:409"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:425: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_uncompressed_write.at:425"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:425"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:426" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:426"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:446: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:446"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:446"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_429
#AT_START_430
at_fn_group_banner 430 'mat5_uncompressed_write.at:449' \
  "Write 2D double-precision complex array" "        " 9
at_xfail=no
(
  $as_echo "430. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:451: \$builddir/test_mat -v 5 -c double write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c double write_complex_2d_numeric" "mat5_uncompressed_write.at:451"
( $at_check_trace; $builddir/test_mat -v 5 -c double write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:451"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:467: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:467"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:467"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:468" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:468"
cat >test_write_complex_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:488: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:488"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:488"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_430
#AT_START_431
at_fn_group_banner 431 'mat5_uncompressed_write.at:491' \
  "Write 2D single-precision complex array" "        " 9
at_xfail=no
(
  $as_echo "431. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:493: \$builddir/test_mat -v 5 -c single write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c single write_complex_2d_numeric" "mat5_uncompressed_write.at:493"
( $at_check_trace; $builddir/test_mat -v 5 -c single write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:493"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:509: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:509"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:509"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:510" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:510"
cat >test_write_complex_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = single(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:530: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:530"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:530"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_431
#AT_START_432
at_fn_group_banner 432 'mat5_uncompressed_write.at:533' \
  "Write 2D 64-bit integer complex array" "          " 9
at_xfail=no
(
  $as_echo "432. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:534" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:534"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:536: \$builddir/test_mat -v 5 -c int64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int64 write_complex_2d_numeric" "mat5_uncompressed_write.at:536"
( $at_check_trace; $builddir/test_mat -v 5 -c int64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:536"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:552: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:552"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:552"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:553" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:553"
cat >test_write_complex_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:573: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:573"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:573"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_432
#AT_START_433
at_fn_group_banner 433 'mat5_uncompressed_write.at:576' \
  "Write 2D 64-bit unsigned integer complex array" " " 9
at_xfail=no
(
  $as_echo "433. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:577" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:577"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:579: \$builddir/test_mat -v 5 -c uint64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint64 write_complex_2d_numeric" "mat5_uncompressed_write.at:579"
( $at_check_trace; $builddir/test_mat -v 5 -c uint64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:579"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:595: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:595"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:595"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:596" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:596"
cat >test_write_complex_2d_numeric_uint64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:616: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:616"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:616"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_433
#AT_START_434
at_fn_group_banner 434 'mat5_uncompressed_write.at:619' \
  "Write 2D 32-bit integer complex array" "          " 9
at_xfail=no
(
  $as_echo "434. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:621: \$builddir/test_mat -v 5 -c int32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int32 write_complex_2d_numeric" "mat5_uncompressed_write.at:621"
( $at_check_trace; $builddir/test_mat -v 5 -c int32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:621"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:637: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:637"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:637"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:638" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:638"
cat >test_write_complex_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:658: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:658"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:658"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_434
#AT_START_435
at_fn_group_banner 435 'mat5_uncompressed_write.at:661' \
  "Write 2D 32-bit unsigned integer complex array" " " 9
at_xfail=no
(
  $as_echo "435. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:663: \$builddir/test_mat -v 5 -c uint32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint32 write_complex_2d_numeric" "mat5_uncompressed_write.at:663"
( $at_check_trace; $builddir/test_mat -v 5 -c uint32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:663"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:679: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:679"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:679"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:680" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:680"
cat >test_write_complex_2d_numeric_uint32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:700: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:700"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:700"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_435
#AT_START_436
at_fn_group_banner 436 'mat5_uncompressed_write.at:703' \
  "Write 2D 16-bit integer complex array" "          " 9
at_xfail=no
(
  $as_echo "436. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:705: \$builddir/test_mat -v 5 -c int16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int16 write_complex_2d_numeric" "mat5_uncompressed_write.at:705"
( $at_check_trace; $builddir/test_mat -v 5 -c int16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:705"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:721: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:721"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:721"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:722" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:722"
cat >test_write_complex_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:742: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:742"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:742"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_436
#AT_START_437
at_fn_group_banner 437 'mat5_uncompressed_write.at:745' \
  "Write 2D 16-bit unsigned integer complex array" " " 9
at_xfail=no
(
  $as_echo "437. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:747: \$builddir/test_mat -v 5 -c uint16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint16 write_complex_2d_numeric" "mat5_uncompressed_write.at:747"
( $at_check_trace; $builddir/test_mat -v 5 -c uint16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:747"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:763: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:763"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:763"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:764" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:764"
cat >test_write_complex_2d_numeric_uint16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:784: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:784"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:784"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_437
#AT_START_438
at_fn_group_banner 438 'mat5_uncompressed_write.at:787' \
  "Write 2D 8-bit integer complex array" "           " 9
at_xfail=no
(
  $as_echo "438. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:789: \$builddir/test_mat -v 5 -c int8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int8 write_complex_2d_numeric" "mat5_uncompressed_write.at:789"
( $at_check_trace; $builddir/test_mat -v 5 -c int8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:789"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:805: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:805"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:805"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:806" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:806"
cat >test_write_complex_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:826: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:826"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:826"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_438
#AT_START_439
at_fn_group_banner 439 'mat5_uncompressed_write.at:829' \
  "Write 2D 8-bit unsigned integer complex array" "  " 9
at_xfail=no
(
  $as_echo "439. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:831: \$builddir/test_mat -v 5 -c uint8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint8 write_complex_2d_numeric" "mat5_uncompressed_write.at:831"
( $at_check_trace; $builddir/test_mat -v 5 -c uint8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:831"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:847: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:847"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:847"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:848" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:848"
cat >test_write_complex_2d_numeric_uint8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:868: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:868"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:868"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_439
#AT_START_440
at_fn_group_banner 440 'mat5_uncompressed_write.at:871' \
  "Write 2D sparse double-precision array" "         " 9
at_xfail=no
(
  $as_echo "440. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:873: \$builddir/test_mat -v 5 -c double write_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c double write_sparse" "mat5_uncompressed_write.at:873"
( $at_check_trace; $builddir/test_mat -v 5 -c double write_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:873"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (5,1)  5
    (2,2)  7
    (3,2)  8
    (4,2)  9
    (1,3)  11
    (5,3)  15
    (2,4)  17
    (3,4)  18
    (4,4)  19
    (1,5)  21
    (5,5)  25
    (2,6)  27
    (3,6)  28
    (4,6)  29
    (1,7)  31
    (5,7)  35
    (2,8)  37
    (3,8)  38
    (4,8)  39
    (1,9)  41
    (5,9)  45
    (2,10)  47
    (3,10)  48
    (4,10)  49
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:909: \$builddir/test_mat readvar test_write_sparse.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse.mat sparse_matrix" "mat5_uncompressed_write.at:909"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:909"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:910" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:910"
cat >test_write_sparse_double.m <<'_ATEOF'

try
    load test_write_sparse.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:934: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:934"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:934"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_440
#AT_START_441
at_fn_group_banner 441 'mat5_uncompressed_write.at:937' \
  "Write 2D sparse complex double-precision array" " " 9
at_xfail=no
(
  $as_echo "441. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:939: \$builddir/test_mat -v 5 -c double write_complex_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c double write_complex_sparse" "mat5_uncompressed_write.at:939"
( $at_check_trace; $builddir/test_mat -v 5 -c double write_complex_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:939"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 51i
    (5,1)  5 + 55i
    (2,2)  7 + 57i
    (3,2)  8 + 58i
    (4,2)  9 + 59i
    (1,3)  11 + 61i
    (5,3)  15 + 65i
    (2,4)  17 + 67i
    (3,4)  18 + 68i
    (4,4)  19 + 69i
    (1,5)  21 + 71i
    (5,5)  25 + 75i
    (2,6)  27 + 77i
    (3,6)  28 + 78i
    (4,6)  29 + 79i
    (1,7)  31 + 81i
    (5,7)  35 + 85i
    (2,8)  37 + 87i
    (3,8)  38 + 88i
    (4,8)  39 + 89i
    (1,9)  41 + 91i
    (5,9)  45 + 95i
    (2,10)  47 + 97i
    (3,10)  48 + 98i
    (4,10)  49 + 99i
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:975: \$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix" "mat5_uncompressed_write.at:975"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:975"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:976" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:976"
cat >test_write_sparse_complex_double.m <<'_ATEOF'

try
    load test_write_sparse_complex.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1000: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1000"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1000"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_441
#AT_START_442
at_fn_group_banner 442 'mat5_uncompressed_write.at:1003' \
  "Write 2D empty array" "                           " 9
at_xfail=no
(
  $as_echo "442. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1005: \$builddir/test_mat -v 5 -c double write_empty_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c double write_empty_2d_numeric" "mat5_uncompressed_write.at:1005"
( $at_check_trace; $builddir/test_mat -v 5 -c double write_empty_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1005"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: empty
      Rank: 2
Dimensions: 0 x 10
Class Type: Double Precision Array
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1013: \$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty" "mat5_uncompressed_write.at:1013"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_2d_numeric.mat empty
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1013"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1014" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1014"
cat >test_write_empty.m <<'_ATEOF'

try
    load test_write_empty_2d_numeric.mat
    expdata = zeros(0,10);
    pass = true;
    pass = pass && isa(empty,class(expdata));
    pass = pass && isempty(empty);
    pass = pass && all(size(empty)==size(expdata));
    pass = pass && all(empty(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1035: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1035"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1035"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_442
#AT_START_443
at_fn_group_banner 443 'mat5_uncompressed_write.at:1038' \
  "Write character array" "                          " 9
at_xfail=no
(
  $as_echo "443. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1039: \$builddir/test_mat -v 5 write_char"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_char" "mat5_uncompressed_write.at:1039"
( $at_check_trace; $builddir/test_mat -v 5 write_char
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1039"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#$%^&*()-_=+`~
[{]}\|;:'",<.>/?          
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1054: \$builddir/test_mat readvar test_write_char.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_char.mat a" "mat5_uncompressed_write.at:1054"
( $at_check_trace; $builddir/test_mat readvar test_write_char.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1054"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1055" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1055"
cat >test_write_char.m <<'_ATEOF'

try
    load test_write_char.mat
    expdata = ['abcdefghijklmnopqrstuvwxyz';
               'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
               '1234567890!@#$%^&*()-_=+`~';
               '[{]}\|;:''",<.>/?          '];
    pass = true;
    pass = pass && isequal(expdata,a);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1076: \$MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1076"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1076"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_443
#AT_START_444
at_fn_group_banner 444 'mat5_uncompressed_write.at:1079' \
  "Write empty structure array" "                    " 9
at_xfail=no
(
  $as_echo "444. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1081: \$builddir/test_mat -v 5 write_empty_struct"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_empty_struct" "mat5_uncompressed_write.at:1081"
( $at_check_trace; $builddir/test_mat -v 5 write_empty_struct
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1081"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1092: \$builddir/test_mat readvar test_write_empty_struct.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var1" "mat5_uncompressed_write.at:1092"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1092"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1107: \$builddir/test_mat readvar test_write_empty_struct.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var2" "mat5_uncompressed_write.at:1107"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1107"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var3
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1126: \$builddir/test_mat readvar test_write_empty_struct.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var3" "mat5_uncompressed_write.at:1126"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1126"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var4
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1159: \$builddir/test_mat readvar test_write_empty_struct.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var4" "mat5_uncompressed_write.at:1159"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1159"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1160" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1160"
cat >test_write_empty_struct.m <<'_ATEOF'

try
    load test_write_empty_struct.mat
    expdata1 = repmat(struct,0,1);
    expdata2 = repmat(struct('field1',zeros(0,0),'field2',zeros(0,0)),0,1);
    expdata3 = struct('field1',zeros(0,1),'field2',zeros(0,1));
    expdata4(1).field1 = zeros(0,1);
    expdata4(1).field2 = repmat(' ',0,1);
    expdata4(2).field1 = repmat(struct,0,1);
    expdata4(2).field2 = repmat({zeros(0,0)},0,1);
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
    pass = pass && isequal(var3,expdata3);
    pass = pass && isequal(var4,expdata4(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1187: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1187"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1187"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_444
#AT_START_445
at_fn_group_banner 445 'mat5_uncompressed_write.at:1190' \
  "Write structure array with 2D double-precision fields" "" 9
at_xfail=no
(
  $as_echo "445. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1192: \$builddir/test_mat -v 5 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_struct_2d_numeric" "mat5_uncompressed_write.at:1192"
( $at_check_trace; $builddir/test_mat -v 5 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1192"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1243: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1243"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1243"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1244" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1244"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape((1:12),3,4);
    expdata(1).field2 = reshape((13:24),3,4);
    expdata(2).field1 = reshape((25:36),3,4);
    expdata(2).field2 = reshape((37:48),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1269: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1269"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1269"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_445
#AT_START_446
at_fn_group_banner 446 'mat5_uncompressed_write.at:1272' \
  "Write structure array with 2D single-precision fields" "" 9
at_xfail=no
(
  $as_echo "446. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1274: \$builddir/test_mat -v 5 -c single write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c single write_struct_2d_numeric" "mat5_uncompressed_write.at:1274"
( $at_check_trace; $builddir/test_mat -v 5 -c single write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1274"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1325: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1325"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1325"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1326" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1326"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12)),3,4);
    expdata(1).field2 = reshape(single((13:24)),3,4);
    expdata(2).field1 = reshape(single((25:36)),3,4);
    expdata(2).field2 = reshape(single((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1351: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1351"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1351"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_446
#AT_START_447
at_fn_group_banner 447 'mat5_uncompressed_write.at:1354' \
  "Write structure array with 2D 64-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "447. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:1355" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1355"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1357: \$builddir/test_mat -v 5 -c int64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int64 write_struct_2d_numeric" "mat5_uncompressed_write.at:1357"
( $at_check_trace; $builddir/test_mat -v 5 -c int64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1357"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1408: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1408"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1408"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1409" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1409"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12)),3,4);
    expdata(1).field2 = reshape(int64((13:24)),3,4);
    expdata(2).field1 = reshape(int64((25:36)),3,4);
    expdata(2).field2 = reshape(int64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1434: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1434"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1434"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_447
#AT_START_448
at_fn_group_banner 448 'mat5_uncompressed_write.at:1437' \
  "Write structure array with 2D 64-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "448. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:1438" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1438"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1440: \$builddir/test_mat -v 5 -c uint64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint64 write_struct_2d_numeric" "mat5_uncompressed_write.at:1440"
( $at_check_trace; $builddir/test_mat -v 5 -c uint64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1440"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1491: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1491"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1491"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1492" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1492"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12)),3,4);
    expdata(1).field2 = reshape(uint64((13:24)),3,4);
    expdata(2).field1 = reshape(uint64((25:36)),3,4);
    expdata(2).field2 = reshape(uint64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1517: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1517"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1517"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_448
#AT_START_449
at_fn_group_banner 449 'mat5_uncompressed_write.at:1520' \
  "Write structure array with 2D 32-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "449. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1522: \$builddir/test_mat -v 5 -c int32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int32 write_struct_2d_numeric" "mat5_uncompressed_write.at:1522"
( $at_check_trace; $builddir/test_mat -v 5 -c int32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1522"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1573: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1573"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1573"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1574" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1574"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12)),3,4);
    expdata(1).field2 = reshape(int32((13:24)),3,4);
    expdata(2).field1 = reshape(int32((25:36)),3,4);
    expdata(2).field2 = reshape(int32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1599: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1599"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1599"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_449
#AT_START_450
at_fn_group_banner 450 'mat5_uncompressed_write.at:1602' \
  "Write structure array with 2D 32-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "450. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1604: \$builddir/test_mat -v 5 -c uint32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint32 write_struct_2d_numeric" "mat5_uncompressed_write.at:1604"
( $at_check_trace; $builddir/test_mat -v 5 -c uint32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1604"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1655: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1655"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1655"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1656" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1656"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12)),3,4);
    expdata(1).field2 = reshape(uint32((13:24)),3,4);
    expdata(2).field1 = reshape(uint32((25:36)),3,4);
    expdata(2).field2 = reshape(uint32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1681: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1681"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1681"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_450
#AT_START_451
at_fn_group_banner 451 'mat5_uncompressed_write.at:1684' \
  "Write structure array with 2D 16-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "451. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1686: \$builddir/test_mat -v 5 -c int16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int16 write_struct_2d_numeric" "mat5_uncompressed_write.at:1686"
( $at_check_trace; $builddir/test_mat -v 5 -c int16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1686"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1737: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1737"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1737"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1738" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1738"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12)),3,4);
    expdata(1).field2 = reshape(int16((13:24)),3,4);
    expdata(2).field1 = reshape(int16((25:36)),3,4);
    expdata(2).field2 = reshape(int16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1763: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1763"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1763"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_451
#AT_START_452
at_fn_group_banner 452 'mat5_uncompressed_write.at:1766' \
  "Write structure array with 2D 16-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "452. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1768: \$builddir/test_mat -v 5 -c uint16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint16 write_struct_2d_numeric" "mat5_uncompressed_write.at:1768"
( $at_check_trace; $builddir/test_mat -v 5 -c uint16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1768"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1819: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1819"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1819"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1820" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1820"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12)),3,4);
    expdata(1).field2 = reshape(uint16((13:24)),3,4);
    expdata(2).field1 = reshape(uint16((25:36)),3,4);
    expdata(2).field2 = reshape(uint16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1845: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1845"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1845"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_452
#AT_START_453
at_fn_group_banner 453 'mat5_uncompressed_write.at:1848' \
  "Write structure array with 2D 8-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "453. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1850: \$builddir/test_mat -v 5 -c int8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int8 write_struct_2d_numeric" "mat5_uncompressed_write.at:1850"
( $at_check_trace; $builddir/test_mat -v 5 -c int8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1850"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1901: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1901"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1901"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1902" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1902"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12)),3,4);
    expdata(1).field2 = reshape(int8((13:24)),3,4);
    expdata(2).field1 = reshape(int8((25:36)),3,4);
    expdata(2).field2 = reshape(int8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1927: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:1927"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1927"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_453
#AT_START_454
at_fn_group_banner 454 'mat5_uncompressed_write.at:1930' \
  "Write structure array with 2D 8-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "454. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1932: \$builddir/test_mat -v 5 -c uint8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint8 write_struct_2d_numeric" "mat5_uncompressed_write.at:1932"
( $at_check_trace; $builddir/test_mat -v 5 -c uint8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1932"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:1983: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_uncompressed_write.at:1983"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:1983"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:1984" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:1984"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12)),3,4);
    expdata(1).field2 = reshape(uint8((13:24)),3,4);
    expdata(2).field1 = reshape(uint8((25:36)),3,4);
    expdata(2).field2 = reshape(uint8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2009: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2009"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2009"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_454
#AT_START_455
at_fn_group_banner 455 'mat5_uncompressed_write.at:2012' \
  "Write structure array with 2D double-precision complex fields" "" 9
at_xfail=no
(
  $as_echo "455. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2014: \$builddir/test_mat -v 5 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2014"
( $at_check_trace; $builddir/test_mat -v 5 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2014"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2065: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2065"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2065"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2066" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2066"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape((1:12) + j*(51:62),3,4);
    expdata(1).field2 = reshape((13:24) + j*(63:74),3,4);
    expdata(2).field1 = reshape((25:36) + j*(75:86),3,4);
    expdata(2).field2 = reshape((37:48) + j*(87:98),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2091: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2091"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2091"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_455
#AT_START_456
at_fn_group_banner 456 'mat5_uncompressed_write.at:2094' \
  "Write structure array with 2D single-precision complex fields" "" 9
at_xfail=no
(
  $as_echo "456. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2096: \$builddir/test_mat -v 5 -c single write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c single write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2096"
( $at_check_trace; $builddir/test_mat -v 5 -c single write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2096"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2147: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2147"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2147"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2148" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2148"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(single((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(single((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(single((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2173: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2173"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2173"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_456
#AT_START_457
at_fn_group_banner 457 'mat5_uncompressed_write.at:2176' \
  "Write structure array with 2D 64-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "457. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:2177" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2177"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2179: \$builddir/test_mat -v 5 -c int64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int64 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2179"
( $at_check_trace; $builddir/test_mat -v 5 -c int64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2179"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2230: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2230"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2230"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2231" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2231"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2256: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2256"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2256"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_457
#AT_START_458
at_fn_group_banner 458 'mat5_uncompressed_write.at:2259' \
  "Write structure array with 2D 64-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "458. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:2260" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2260"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2262: \$builddir/test_mat -v 5 -c uint64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint64 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2262"
( $at_check_trace; $builddir/test_mat -v 5 -c uint64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2262"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2313: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2313"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2313"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2314" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2314"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2339: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2339"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2339"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_458
#AT_START_459
at_fn_group_banner 459 'mat5_uncompressed_write.at:2342' \
  "Write structure array with 2D 32-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "459. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2344: \$builddir/test_mat -v 5 -c int32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int32 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2344"
( $at_check_trace; $builddir/test_mat -v 5 -c int32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2344"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2395: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2395"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2395"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2396" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2396"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2421: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2421"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2421"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_459
#AT_START_460
at_fn_group_banner 460 'mat5_uncompressed_write.at:2424' \
  "Write structure array with 2D 32-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "460. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2426: \$builddir/test_mat -v 5 -c uint32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint32 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2426"
( $at_check_trace; $builddir/test_mat -v 5 -c uint32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2426"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2477: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2477"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2477"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2478" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2478"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2503: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2503"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2503"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_460
#AT_START_461
at_fn_group_banner 461 'mat5_uncompressed_write.at:2506' \
  "Write structure array with 2D 16-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "461. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2508: \$builddir/test_mat -v 5 -c int16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int16 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2508"
( $at_check_trace; $builddir/test_mat -v 5 -c int16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2508"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2559: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2559"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2559"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2560" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2560"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2585: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2585"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2585"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_461
#AT_START_462
at_fn_group_banner 462 'mat5_uncompressed_write.at:2588' \
  "Write structure array with 2D 16-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "462. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2590: \$builddir/test_mat -v 5 -c uint16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint16 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2590"
( $at_check_trace; $builddir/test_mat -v 5 -c uint16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2590"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2641: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2641"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2641"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2642" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2642"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2667: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2667"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2667"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_462
#AT_START_463
at_fn_group_banner 463 'mat5_uncompressed_write.at:2670' \
  "Write structure array with 2D 8-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "463. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2672: \$builddir/test_mat -v 5 -c int8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int8 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2672"
( $at_check_trace; $builddir/test_mat -v 5 -c int8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2672"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2723: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2723"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2723"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2724" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2724"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2749: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2749"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2749"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_463
#AT_START_464
at_fn_group_banner 464 'mat5_uncompressed_write.at:2752' \
  "Write structure array with 2D 8-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "464. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2754: \$builddir/test_mat -v 5 -c uint8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint8 write_struct_complex_2d_numeric" "mat5_uncompressed_write.at:2754"
( $at_check_trace; $builddir/test_mat -v 5 -c uint8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2754"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2805: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:2805"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2805"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2806" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2806"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2831: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2831"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2831"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_464
#AT_START_465
at_fn_group_banner 465 'mat5_uncompressed_write.at:2834' \
  "Write empty cell array" "                         " 9
at_xfail=no
(
  $as_echo "465. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2835: \$builddir/test_mat -v 5 write_empty_cell"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_empty_cell" "mat5_uncompressed_write.at:2835"
( $at_check_trace; $builddir/test_mat -v 5 write_empty_cell
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2835"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2846: \$builddir/test_mat readvar test_write_empty_cell.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var1" "mat5_uncompressed_write.at:2846"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2846"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
}
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2869: \$builddir/test_mat readvar test_write_empty_cell.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var2" "mat5_uncompressed_write.at:2869"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2869"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2870" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2870"
cat >test_write_empty_cell.m <<'_ATEOF'

try
    load test_write_empty_cell.mat
    expdata1 = cell(0,1);
    expdata2 = {zeros(0,1);zeros(0,1)};
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2890: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2890"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2890"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_465
#AT_START_466
at_fn_group_banner 466 'mat5_uncompressed_write.at:2893' \
  "Write cell array with 2D double-precision fields" "" 9
at_xfail=no
(
  $as_echo "466. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2895: \$builddir/test_mat -v 5 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_cell_2d_numeric" "mat5_uncompressed_write.at:2895"
( $at_check_trace; $builddir/test_mat -v 5 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2895"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2942: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:2942"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2942"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:2943" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:2943"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape((1:12),3,4);reshape((13:24),3,4);...
               reshape((25:36),3,4);reshape((37:48),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2966: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:2966"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2966"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_466
#AT_START_467
at_fn_group_banner 467 'mat5_uncompressed_write.at:2969' \
  "Write cell array with 2D single-precision fields" "" 9
at_xfail=no
(
  $as_echo "467. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:2971: \$builddir/test_mat -v 5 -c single write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c single write_cell_2d_numeric" "mat5_uncompressed_write.at:2971"
( $at_check_trace; $builddir/test_mat -v 5 -c single write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:2971"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3018: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3018"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3018"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3019" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3019"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(single((1:12)),3,4);reshape(single((13:24)),3,4);...
               reshape(single((25:36)),3,4);reshape(single((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3042: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3042"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3042"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_467
#AT_START_468
at_fn_group_banner 468 'mat5_uncompressed_write.at:3045' \
  "Write cell array with 2D 64-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "468. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:3046" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3046"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3048: \$builddir/test_mat -v 5 -c int64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int64 write_cell_2d_numeric" "mat5_uncompressed_write.at:3048"
( $at_check_trace; $builddir/test_mat -v 5 -c int64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3048"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3095: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3095"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3095"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3096" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3096"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int64((1:12)),3,4);reshape(int64((13:24)),3,4);...
               reshape(int64((25:36)),3,4);reshape(int64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3119: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3119"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3119"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_468
#AT_START_469
at_fn_group_banner 469 'mat5_uncompressed_write.at:3122' \
  "Write cell array with 2D 64-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "469. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:3123" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3123"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3125: \$builddir/test_mat -v 5 -c uint64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint64 write_cell_2d_numeric" "mat5_uncompressed_write.at:3125"
( $at_check_trace; $builddir/test_mat -v 5 -c uint64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3125"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3172: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3172"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3172"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3173" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3173"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint64((1:12)),3,4);reshape(uint64((13:24)),3,4);...
               reshape(uint64((25:36)),3,4);reshape(uint64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3196: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3196"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3196"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_469
#AT_START_470
at_fn_group_banner 470 'mat5_uncompressed_write.at:3199' \
  "Write cell array with 2D 32-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "470. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3201: \$builddir/test_mat -v 5 -c int32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int32 write_cell_2d_numeric" "mat5_uncompressed_write.at:3201"
( $at_check_trace; $builddir/test_mat -v 5 -c int32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3201"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3248: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3248"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3248"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3249" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3249"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int32((1:12)),3,4);reshape(int32((13:24)),3,4);...
               reshape(int32((25:36)),3,4);reshape(int32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3272: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3272"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3272"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_470
#AT_START_471
at_fn_group_banner 471 'mat5_uncompressed_write.at:3275' \
  "Write cell array with 2D 32-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "471. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3277: \$builddir/test_mat -v 5 -c uint32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint32 write_cell_2d_numeric" "mat5_uncompressed_write.at:3277"
( $at_check_trace; $builddir/test_mat -v 5 -c uint32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3277"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3324: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3324"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3324"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3325" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3325"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint32((1:12)),3,4);reshape(uint32((13:24)),3,4);...
               reshape(uint32((25:36)),3,4);reshape(uint32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3348: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3348"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3348"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_471
#AT_START_472
at_fn_group_banner 472 'mat5_uncompressed_write.at:3351' \
  "Write cell array with 2D 16-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "472. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3353: \$builddir/test_mat -v 5 -c int16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int16 write_cell_2d_numeric" "mat5_uncompressed_write.at:3353"
( $at_check_trace; $builddir/test_mat -v 5 -c int16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3353"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3400: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3400"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3400"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3401" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3401"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int16((1:12)),3,4);reshape(int16((13:24)),3,4);...
               reshape(int16((25:36)),3,4);reshape(int16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3424: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3424"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3424"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_472
#AT_START_473
at_fn_group_banner 473 'mat5_uncompressed_write.at:3427' \
  "Write cell array with 2D 16-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "473. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3429: \$builddir/test_mat -v 5 -c uint16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint16 write_cell_2d_numeric" "mat5_uncompressed_write.at:3429"
( $at_check_trace; $builddir/test_mat -v 5 -c uint16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3429"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3476: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3476"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3476"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3477" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3477"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint16((1:12)),3,4);reshape(uint16((13:24)),3,4);...
               reshape(uint16((25:36)),3,4);reshape(uint16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3500: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3500"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3500"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_473
#AT_START_474
at_fn_group_banner 474 'mat5_uncompressed_write.at:3503' \
  "Write cell array with 2D 8-bit signed integer fields" "" 9
at_xfail=no
(
  $as_echo "474. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3505: \$builddir/test_mat -v 5 -c int8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int8 write_cell_2d_numeric" "mat5_uncompressed_write.at:3505"
( $at_check_trace; $builddir/test_mat -v 5 -c int8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3505"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3552: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3552"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3552"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3553" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3553"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int8((1:12)),3,4);reshape(int8((13:24)),3,4);...
               reshape(int8((25:36)),3,4);reshape(int8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3576: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3576"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3576"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_474
#AT_START_475
at_fn_group_banner 475 'mat5_uncompressed_write.at:3579' \
  "Write cell array with 2D 8-bit unsigned integer fields" "" 9
at_xfail=no
(
  $as_echo "475. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3581: \$builddir/test_mat -v 5 -c uint8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint8 write_cell_2d_numeric" "mat5_uncompressed_write.at:3581"
( $at_check_trace; $builddir/test_mat -v 5 -c uint8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3581"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3628: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_uncompressed_write.at:3628"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3628"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3629" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3629"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint8((1:12)),3,4);reshape(uint8((13:24)),3,4);...
               reshape(uint8((25:36)),3,4);reshape(uint8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3652: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3652"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3652"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_475
#AT_START_476
at_fn_group_banner 476 'mat5_uncompressed_write.at:3655' \
  "Write cell array with 2D double-precision complex fields" "" 9
at_xfail=no
(
  $as_echo "476. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3657: \$builddir/test_mat -v 5 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:3657"
( $at_check_trace; $builddir/test_mat -v 5 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3657"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3704: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:3704"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3704"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3705" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3705"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape((1:12)+j*(51:62),3,4);...
               reshape((13:24)+j*(63:74),3,4);...
               reshape((25:36)+j*(75:86),3,4);...
               reshape((37:48)+j*(87:98),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3730: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3730"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3730"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_476
#AT_START_477
at_fn_group_banner 477 'mat5_uncompressed_write.at:3733' \
  "Write cell array with 2D single-precision complex fields" "" 9
at_xfail=no
(
  $as_echo "477. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3735: \$builddir/test_mat -v 5 -c single write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c single write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:3735"
( $at_check_trace; $builddir/test_mat -v 5 -c single write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3735"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3782: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:3782"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3782"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3783" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3783"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(single((1:12)+j*(51:62)),3,4);...
               reshape(single((13:24)+j*(63:74)),3,4);...
               reshape(single((25:36)+j*(75:86)),3,4);...
               reshape(single((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3808: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3808"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3808"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_477
#AT_START_478
at_fn_group_banner 478 'mat5_uncompressed_write.at:3811' \
  "Write cell array with 2D 64-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "478. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:3812" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3812"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3814: \$builddir/test_mat -v 5 -c int64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int64 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:3814"
( $at_check_trace; $builddir/test_mat -v 5 -c int64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3814"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3861: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:3861"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3861"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3862" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3862"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int64((1:12)+j*(51:62)),3,4);...
               reshape(int64((13:24)+j*(63:74)),3,4);...
               reshape(int64((25:36)+j*(75:86)),3,4);...
               reshape(int64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3887: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3887"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3887"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_478
#AT_START_479
at_fn_group_banner 479 'mat5_uncompressed_write.at:3890' \
  "Write cell array with 2D 64-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "479. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_uncompressed_write.at:3891" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3891"
{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3893: \$builddir/test_mat -v 5 -c uint64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint64 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:3893"
( $at_check_trace; $builddir/test_mat -v 5 -c uint64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3893"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3940: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:3940"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3940"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:3941" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:3941"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint64((1:12)+j*(51:62)),3,4);...
               reshape(uint64((13:24)+j*(63:74)),3,4);...
               reshape(uint64((25:36)+j*(75:86)),3,4);...
               reshape(uint64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3966: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:3966"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3966"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_479
#AT_START_480
at_fn_group_banner 480 'mat5_uncompressed_write.at:3969' \
  "Write cell array with 2D 32-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "480. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:3971: \$builddir/test_mat -v 5 -c int32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int32 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:3971"
( $at_check_trace; $builddir/test_mat -v 5 -c int32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:3971"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4018: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:4018"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4018"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:4019" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:4019"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int32((1:12)+j*(51:62)),3,4);...
               reshape(int32((13:24)+j*(63:74)),3,4);...
               reshape(int32((25:36)+j*(75:86)),3,4);...
               reshape(int32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4044: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:4044"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4044"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_480
#AT_START_481
at_fn_group_banner 481 'mat5_uncompressed_write.at:4047' \
  "Write cell array with 2D 32-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "481. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4049: \$builddir/test_mat -v 5 -c uint32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint32 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:4049"
( $at_check_trace; $builddir/test_mat -v 5 -c uint32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4049"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4096: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:4096"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4096"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:4097" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:4097"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint32((1:12)+j*(51:62)),3,4);...
               reshape(uint32((13:24)+j*(63:74)),3,4);...
               reshape(uint32((25:36)+j*(75:86)),3,4);...
               reshape(uint32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4122: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:4122"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4122"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_481
#AT_START_482
at_fn_group_banner 482 'mat5_uncompressed_write.at:4125' \
  "Write cell array with 2D 16-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "482. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4127: \$builddir/test_mat -v 5 -c int16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int16 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:4127"
( $at_check_trace; $builddir/test_mat -v 5 -c int16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4127"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4174: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:4174"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4174"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:4175" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:4175"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int16((1:12)+j*(51:62)),3,4);...
               reshape(int16((13:24)+j*(63:74)),3,4);...
               reshape(int16((25:36)+j*(75:86)),3,4);...
               reshape(int16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4200: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:4200"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4200"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_482
#AT_START_483
at_fn_group_banner 483 'mat5_uncompressed_write.at:4203' \
  "Write cell array with 2D 16-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "483. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4205: \$builddir/test_mat -v 5 -c uint16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint16 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:4205"
( $at_check_trace; $builddir/test_mat -v 5 -c uint16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4205"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4252: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:4252"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4252"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:4253" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:4253"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint16((1:12)+j*(51:62)),3,4);...
               reshape(uint16((13:24)+j*(63:74)),3,4);...
               reshape(uint16((25:36)+j*(75:86)),3,4);...
               reshape(uint16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4278: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:4278"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4278"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_483
#AT_START_484
at_fn_group_banner 484 'mat5_uncompressed_write.at:4281' \
  "Write cell array with 2D 8-bit signed integer complex fields" "" 9
at_xfail=no
(
  $as_echo "484. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4283: \$builddir/test_mat -v 5 -c int8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c int8 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:4283"
( $at_check_trace; $builddir/test_mat -v 5 -c int8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4283"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4330: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:4330"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4330"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:4331" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:4331"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int8((1:12)+j*(51:62)),3,4);...
               reshape(int8((13:24)+j*(63:74)),3,4);...
               reshape(int8((25:36)+j*(75:86)),3,4);...
               reshape(int8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4356: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:4356"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4356"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_484
#AT_START_485
at_fn_group_banner 485 'mat5_uncompressed_write.at:4359' \
  "Write cell array with 2D 8-bit unsigned integer complex fields" "" 9
at_xfail=no
(
  $as_echo "485. $at_setup_line: testing $at_desc ..."
  $at_traceon

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4361: \$builddir/test_mat -v 5 -c uint8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -c uint8 write_cell_complex_2d_numeric" "mat5_uncompressed_write.at:4361"
( $at_check_trace; $builddir/test_mat -v 5 -c uint8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4361"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4408: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_uncompressed_write.at:4408"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4408"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_uncompressed_write.at:4409" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_uncompressed_write.at:4409"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint8((1:12)+j*(51:62)),3,4);...
               reshape(uint8((13:24)+j*(63:74)),3,4);...
               reshape(uint8((25:36)+j*(75:86)),3,4);...
               reshape(uint8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_uncompressed_write.at:4434: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_uncompressed_write.at:4434"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_uncompressed_write.at:4434"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_485
#AT_START_486
at_fn_group_banner 486 'mat5_compressed_write.at:27' \
  "Write 2D double-precision array" "                " 10
at_xfail=no
(
  $as_echo "486. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:28" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:28"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:30: \$builddir/test_mat -v 5 -z -c double write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c double write_2d_numeric" "mat5_compressed_write.at:30"
( $at_check_trace; $builddir/test_mat -v 5 -z -c double write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:30"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:46: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:46"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:46"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:47" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:47"
cat >test_write_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:67: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:67"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:67"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_486
#AT_START_487
at_fn_group_banner 487 'mat5_compressed_write.at:70' \
  "Write 2D single-precision array" "                " 10
at_xfail=no
(
  $as_echo "487. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:71" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:71"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:73: \$builddir/test_mat -v 5 -z -c single write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c single write_2d_numeric" "mat5_compressed_write.at:73"
( $at_check_trace; $builddir/test_mat -v 5 -z -c single write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:73"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:89: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:89"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:89"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:90" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:90"
cat >test_write_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = single(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:110: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:110"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:110"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_487
#AT_START_488
at_fn_group_banner 488 'mat5_compressed_write.at:113' \
  "Write 2D 64-bit integer array" "                  " 10
at_xfail=no
(
  $as_echo "488. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:114" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:114"
$as_echo "mat5_compressed_write.at:115" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:115"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:117: \$builddir/test_mat -v 5 -z -c int64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int64 write_2d_numeric" "mat5_compressed_write.at:117"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:117"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:133: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:133"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:133"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:134" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:134"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:154: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:154"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:154"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_488
#AT_START_489
at_fn_group_banner 489 'mat5_compressed_write.at:157' \
  "Write 2D 64-bit unsigned integer array" "         " 10
at_xfail=no
(
  $as_echo "489. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:158" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:158"
$as_echo "mat5_compressed_write.at:159" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:159"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:161: \$builddir/test_mat -v 5 -z -c uint64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint64 write_2d_numeric" "mat5_compressed_write.at:161"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:161"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:177: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:177"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:177"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:178" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:178"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:198: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:198"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:198"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_489
#AT_START_490
at_fn_group_banner 490 'mat5_compressed_write.at:201' \
  "Write 2D 32-bit integer array" "                  " 10
at_xfail=no
(
  $as_echo "490. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:202" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:202"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:204: \$builddir/test_mat -v 5 -z -c int32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int32 write_2d_numeric" "mat5_compressed_write.at:204"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:204"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:220: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:220"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:220"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:221" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:221"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:241: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:241"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:241"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_490
#AT_START_491
at_fn_group_banner 491 'mat5_compressed_write.at:244' \
  "Write 2D 32-bit unsigned integer array" "         " 10
at_xfail=no
(
  $as_echo "491. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:245" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:245"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:247: \$builddir/test_mat -v 5 -z -c uint32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint32 write_2d_numeric" "mat5_compressed_write.at:247"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:247"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:263: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:263"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:263"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:264" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:264"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:284: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:284"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:284"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_491
#AT_START_492
at_fn_group_banner 492 'mat5_compressed_write.at:287' \
  "Write 2D 16-bit integer array" "                  " 10
at_xfail=no
(
  $as_echo "492. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:288" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:288"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:290: \$builddir/test_mat -v 5 -z -c int16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int16 write_2d_numeric" "mat5_compressed_write.at:290"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:290"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:306: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:306"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:306"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:307" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:307"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:327: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:327"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:327"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_492
#AT_START_493
at_fn_group_banner 493 'mat5_compressed_write.at:330' \
  "Write 2D 16-bit unsigned integer array" "         " 10
at_xfail=no
(
  $as_echo "493. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:331" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:331"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:333: \$builddir/test_mat -v 5 -z -c uint16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint16 write_2d_numeric" "mat5_compressed_write.at:333"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:333"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:349: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:349"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:349"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:350" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:350"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:370: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:370"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:370"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_493
#AT_START_494
at_fn_group_banner 494 'mat5_compressed_write.at:373' \
  "Write 2D 8-bit integer array" "                   " 10
at_xfail=no
(
  $as_echo "494. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:374" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:374"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:376: \$builddir/test_mat -v 5 -z -c int8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int8 write_2d_numeric" "mat5_compressed_write.at:376"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:376"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:392: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:392"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:392"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:393" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:393"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:413: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:413"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:413"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_494
#AT_START_495
at_fn_group_banner 495 'mat5_compressed_write.at:416' \
  "Write 2D 8-bit unsigned integer array" "          " 10
at_xfail=no
(
  $as_echo "495. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:417" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:417"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:419: \$builddir/test_mat -v 5 -z -c uint8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint8 write_2d_numeric" "mat5_compressed_write.at:419"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:419"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:435: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat5_compressed_write.at:435"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:435"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:436" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:436"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:456: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:456"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:456"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_495
#AT_START_496
at_fn_group_banner 496 'mat5_compressed_write.at:459' \
  "Write 2D double-precision complex array" "        " 10
at_xfail=no
(
  $as_echo "496. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:460" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:460"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:462: \$builddir/test_mat -v 5 -z -c double write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c double write_complex_2d_numeric" "mat5_compressed_write.at:462"
( $at_check_trace; $builddir/test_mat -v 5 -z -c double write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:462"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:478: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:478"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:478"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:479" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:479"
cat >test_write_complex_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:499: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:499"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:499"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_496
#AT_START_497
at_fn_group_banner 497 'mat5_compressed_write.at:502' \
  "Write 2D single-precision complex array" "        " 10
at_xfail=no
(
  $as_echo "497. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:503" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:503"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:505: \$builddir/test_mat -v 5 -z -c single write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c single write_complex_2d_numeric" "mat5_compressed_write.at:505"
( $at_check_trace; $builddir/test_mat -v 5 -z -c single write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:505"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:521: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:521"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:521"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:522" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:522"
cat >test_write_complex_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = single(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:542: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:542"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:542"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_497
#AT_START_498
at_fn_group_banner 498 'mat5_compressed_write.at:545' \
  "Write 2D 64-bit integer complex array" "          " 10
at_xfail=no
(
  $as_echo "498. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:546" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:546"
$as_echo "mat5_compressed_write.at:547" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:547"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:549: \$builddir/test_mat -v 5 -z -c int64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int64 write_complex_2d_numeric" "mat5_compressed_write.at:549"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:549"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:565: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:565"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:565"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:566" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:566"
cat >test_write_complex_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:586: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:586"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:586"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_498
#AT_START_499
at_fn_group_banner 499 'mat5_compressed_write.at:589' \
  "Write 2D 64-bit unsigned integer complex array" " " 10
at_xfail=no
(
  $as_echo "499. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:590" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:590"
$as_echo "mat5_compressed_write.at:591" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:591"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:593: \$builddir/test_mat -v 5 -z -c uint64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint64 write_complex_2d_numeric" "mat5_compressed_write.at:593"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:593"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:609: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:609"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:609"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:610" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:610"
cat >test_write_complex_2d_numeric_uint64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:630: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:630"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:630"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_499
#AT_START_500
at_fn_group_banner 500 'mat5_compressed_write.at:633' \
  "Write 2D 32-bit integer complex array" "          " 10
at_xfail=no
(
  $as_echo "500. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:634" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:634"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:636: \$builddir/test_mat -v 5 -z -c int32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int32 write_complex_2d_numeric" "mat5_compressed_write.at:636"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:636"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:652: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:652"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:652"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:653" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:653"
cat >test_write_complex_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:673: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:673"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:673"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_500
#AT_START_501
at_fn_group_banner 501 'mat5_compressed_write.at:676' \
  "Write 2D 32-bit unsigned integer complex array" " " 10
at_xfail=no
(
  $as_echo "501. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:677" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:677"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:679: \$builddir/test_mat -v 5 -z -c uint32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint32 write_complex_2d_numeric" "mat5_compressed_write.at:679"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:679"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:695: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:695"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:695"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:696" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:696"
cat >test_write_complex_2d_numeric_uint32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:716: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:716"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:716"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_501
#AT_START_502
at_fn_group_banner 502 'mat5_compressed_write.at:719' \
  "Write 2D 16-bit integer complex array" "          " 10
at_xfail=no
(
  $as_echo "502. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:720" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:720"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:722: \$builddir/test_mat -v 5 -z -c int16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int16 write_complex_2d_numeric" "mat5_compressed_write.at:722"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:722"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:738: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:738"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:738"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:739" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:739"
cat >test_write_complex_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:759: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:759"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:759"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_502
#AT_START_503
at_fn_group_banner 503 'mat5_compressed_write.at:762' \
  "Write 2D 16-bit unsigned integer complex array" " " 10
at_xfail=no
(
  $as_echo "503. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:763" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:763"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:765: \$builddir/test_mat -v 5 -z -c uint16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint16 write_complex_2d_numeric" "mat5_compressed_write.at:765"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:765"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:781: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:781"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:781"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:782" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:782"
cat >test_write_complex_2d_numeric_uint16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:802: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:802"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:802"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_503
#AT_START_504
at_fn_group_banner 504 'mat5_compressed_write.at:805' \
  "Write 2D 8-bit integer complex array" "           " 10
at_xfail=no
(
  $as_echo "504. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:806" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:806"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:808: \$builddir/test_mat -v 5 -z -c int8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int8 write_complex_2d_numeric" "mat5_compressed_write.at:808"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:808"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:824: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:824"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:824"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:825" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:825"
cat >test_write_complex_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:845: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:845"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:845"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_504
#AT_START_505
at_fn_group_banner 505 'mat5_compressed_write.at:848' \
  "Write 2D 8-bit unsigned integer complex array" "  " 10
at_xfail=no
(
  $as_echo "505. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:849" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:849"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:851: \$builddir/test_mat -v 5 -z -c uint8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint8 write_complex_2d_numeric" "mat5_compressed_write.at:851"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:851"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:867: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat5_compressed_write.at:867"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:867"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:868" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:868"
cat >test_write_complex_2d_numeric_uint8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:888: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:888"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:888"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_505
#AT_START_506
at_fn_group_banner 506 'mat5_compressed_write.at:891' \
  "Write 2D sparse double-precision array" "         " 10
at_xfail=no
(
  $as_echo "506. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:892" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:892"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:894: \$builddir/test_mat -v 5 -z -c double write_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c double write_sparse" "mat5_compressed_write.at:894"
( $at_check_trace; $builddir/test_mat -v 5 -z -c double write_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:894"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (5,1)  5
    (2,2)  7
    (3,2)  8
    (4,2)  9
    (1,3)  11
    (5,3)  15
    (2,4)  17
    (3,4)  18
    (4,4)  19
    (1,5)  21
    (5,5)  25
    (2,6)  27
    (3,6)  28
    (4,6)  29
    (1,7)  31
    (5,7)  35
    (2,8)  37
    (3,8)  38
    (4,8)  39
    (1,9)  41
    (5,9)  45
    (2,10)  47
    (3,10)  48
    (4,10)  49
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:930: \$builddir/test_mat readvar test_write_sparse.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse.mat sparse_matrix" "mat5_compressed_write.at:930"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:930"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:931" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:931"
cat >test_write_sparse_double.m <<'_ATEOF'

try
    load test_write_sparse.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:955: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:955"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:955"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_506
#AT_START_507
at_fn_group_banner 507 'mat5_compressed_write.at:958' \
  "Write 2D sparse complex double-precision array" " " 10
at_xfail=no
(
  $as_echo "507. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:959" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:959"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:961: \$builddir/test_mat -v 5 -z -c double write_complex_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c double write_complex_sparse" "mat5_compressed_write.at:961"
( $at_check_trace; $builddir/test_mat -v 5 -z -c double write_complex_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:961"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 51i
    (5,1)  5 + 55i
    (2,2)  7 + 57i
    (3,2)  8 + 58i
    (4,2)  9 + 59i
    (1,3)  11 + 61i
    (5,3)  15 + 65i
    (2,4)  17 + 67i
    (3,4)  18 + 68i
    (4,4)  19 + 69i
    (1,5)  21 + 71i
    (5,5)  25 + 75i
    (2,6)  27 + 77i
    (3,6)  28 + 78i
    (4,6)  29 + 79i
    (1,7)  31 + 81i
    (5,7)  35 + 85i
    (2,8)  37 + 87i
    (3,8)  38 + 88i
    (4,8)  39 + 89i
    (1,9)  41 + 91i
    (5,9)  45 + 95i
    (2,10)  47 + 97i
    (3,10)  48 + 98i
    (4,10)  49 + 99i
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:997: \$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix" "mat5_compressed_write.at:997"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:997"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:998" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:998"
cat >test_write_sparse_complex_double.m <<'_ATEOF'

try
    load test_write_sparse_complex.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1022: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1022"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1022"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_507
#AT_START_508
at_fn_group_banner 508 'mat5_compressed_write.at:1025' \
  "Write 2D empty array" "                           " 10
at_xfail=no
(
  $as_echo "508. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1026" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1026"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1028: \$builddir/test_mat -v 5 -z -c double write_empty_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c double write_empty_2d_numeric" "mat5_compressed_write.at:1028"
( $at_check_trace; $builddir/test_mat -v 5 -z -c double write_empty_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1028"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: empty
      Rank: 2
Dimensions: 0 x 10
Class Type: Double Precision Array
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1036: \$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty" "mat5_compressed_write.at:1036"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_2d_numeric.mat empty
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1036"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1037" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1037"
cat >test_write_empty.m <<'_ATEOF'

try
    load test_write_empty_2d_numeric.mat
    expdata = zeros(0,10);
    pass = true;
    pass = pass && isa(empty,class(expdata));
    pass = pass && isempty(empty);
    pass = pass && all(size(empty)==size(expdata));
    pass = pass && all(empty(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1058: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1058"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1058"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_508
#AT_START_509
at_fn_group_banner 509 'mat5_compressed_write.at:1061' \
  "Write character array" "                          " 10
at_xfail=no
(
  $as_echo "509. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1062" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1062"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1063: \$builddir/test_mat -v 5 -z write_char"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_char" "mat5_compressed_write.at:1063"
( $at_check_trace; $builddir/test_mat -v 5 -z write_char
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1063"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#$%^&*()-_=+`~
[{]}\|;:'",<.>/?          
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1078: \$builddir/test_mat readvar test_write_char.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_char.mat a" "mat5_compressed_write.at:1078"
( $at_check_trace; $builddir/test_mat readvar test_write_char.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1078"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1079" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1079"
cat >test_write_char.m <<'_ATEOF'

try
    load test_write_char.mat
    expdata = ['abcdefghijklmnopqrstuvwxyz';
               'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
               '1234567890!@#$%^&*()-_=+`~';
               '[{]}\|;:''",<.>/?          '];
    pass = true;
    pass = pass && isequal(expdata,a);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1100: \$MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1100"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1100"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_509
#AT_START_510
at_fn_group_banner 510 'mat5_compressed_write.at:1103' \
  "Write empty structure array" "                    " 10
at_xfail=no
(
  $as_echo "510. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1104" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1104"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1106: \$builddir/test_mat -v 5 -z write_empty_struct"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_empty_struct" "mat5_compressed_write.at:1106"
( $at_check_trace; $builddir/test_mat -v 5 -z write_empty_struct
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1106"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1117: \$builddir/test_mat readvar test_write_empty_struct.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var1" "mat5_compressed_write.at:1117"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1117"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1132: \$builddir/test_mat readvar test_write_empty_struct.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var2" "mat5_compressed_write.at:1132"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1132"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var3
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1151: \$builddir/test_mat readvar test_write_empty_struct.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var3" "mat5_compressed_write.at:1151"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1151"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var4
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1184: \$builddir/test_mat readvar test_write_empty_struct.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var4" "mat5_compressed_write.at:1184"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1184"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1185" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1185"
cat >test_write_empty_struct.m <<'_ATEOF'

try
    load test_write_empty_struct.mat
    expdata1 = repmat(struct,0,1);
    expdata2 = repmat(struct('field1',zeros(0,0),'field2',zeros(0,0)),0,1);
    expdata3 = struct('field1',zeros(0,1),'field2',zeros(0,1));
    expdata4(1).field1 = zeros(0,1);
    expdata4(1).field2 = repmat(' ',0,1);
    expdata4(2).field1 = repmat(struct,0,1);
    expdata4(2).field2 = repmat({zeros(0,0)},0,1);
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
    pass = pass && isequal(var3,expdata3);
    pass = pass && isequal(var4,expdata4(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1212: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1212"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1212"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_510
#AT_START_511
at_fn_group_banner 511 'mat5_compressed_write.at:1215' \
  "Write structure array with 2D double-precision fields" "" 10
at_xfail=no
(
  $as_echo "511. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1216" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1216"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1218: \$builddir/test_mat -v 5 -z write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_struct_2d_numeric" "mat5_compressed_write.at:1218"
( $at_check_trace; $builddir/test_mat -v 5 -z write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1218"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1269: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1269"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1269"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1270" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1270"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape((1:12),3,4);
    expdata(1).field2 = reshape((13:24),3,4);
    expdata(2).field1 = reshape((25:36),3,4);
    expdata(2).field2 = reshape((37:48),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1295: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1295"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1295"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_511
#AT_START_512
at_fn_group_banner 512 'mat5_compressed_write.at:1298' \
  "Write structure array with 2D single-precision fields" "" 10
at_xfail=no
(
  $as_echo "512. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1299" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1299"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1301: \$builddir/test_mat -v 5 -z -c single write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c single write_struct_2d_numeric" "mat5_compressed_write.at:1301"
( $at_check_trace; $builddir/test_mat -v 5 -z -c single write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1301"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1352: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1352"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1352"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1353" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1353"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12)),3,4);
    expdata(1).field2 = reshape(single((13:24)),3,4);
    expdata(2).field1 = reshape(single((25:36)),3,4);
    expdata(2).field2 = reshape(single((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1378: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1378"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1378"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_512
#AT_START_513
at_fn_group_banner 513 'mat5_compressed_write.at:1381' \
  "Write structure array with 2D 64-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "513. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1382" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1382"
$as_echo "mat5_compressed_write.at:1383" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1383"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1385: \$builddir/test_mat -v 5 -z -c int64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int64 write_struct_2d_numeric" "mat5_compressed_write.at:1385"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1385"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1436: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1436"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1436"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1437" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1437"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12)),3,4);
    expdata(1).field2 = reshape(int64((13:24)),3,4);
    expdata(2).field1 = reshape(int64((25:36)),3,4);
    expdata(2).field2 = reshape(int64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1462: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1462"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1462"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_513
#AT_START_514
at_fn_group_banner 514 'mat5_compressed_write.at:1465' \
  "Write structure array with 2D 64-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "514. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1466" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1466"
$as_echo "mat5_compressed_write.at:1467" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1467"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1469: \$builddir/test_mat -v 5 -z -c uint64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint64 write_struct_2d_numeric" "mat5_compressed_write.at:1469"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1469"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1520: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1520"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1520"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1521" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1521"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12)),3,4);
    expdata(1).field2 = reshape(uint64((13:24)),3,4);
    expdata(2).field1 = reshape(uint64((25:36)),3,4);
    expdata(2).field2 = reshape(uint64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1546: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1546"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1546"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_514
#AT_START_515
at_fn_group_banner 515 'mat5_compressed_write.at:1549' \
  "Write structure array with 2D 32-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "515. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1550" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1550"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1552: \$builddir/test_mat -v 5 -z -c int32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int32 write_struct_2d_numeric" "mat5_compressed_write.at:1552"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1552"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1603: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1603"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1603"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1604" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1604"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12)),3,4);
    expdata(1).field2 = reshape(int32((13:24)),3,4);
    expdata(2).field1 = reshape(int32((25:36)),3,4);
    expdata(2).field2 = reshape(int32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1629: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1629"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1629"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_515
#AT_START_516
at_fn_group_banner 516 'mat5_compressed_write.at:1632' \
  "Write structure array with 2D 32-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "516. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1633" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1633"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1635: \$builddir/test_mat -v 5 -z -c uint32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint32 write_struct_2d_numeric" "mat5_compressed_write.at:1635"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1635"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1686: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1686"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1686"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1687" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1687"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12)),3,4);
    expdata(1).field2 = reshape(uint32((13:24)),3,4);
    expdata(2).field1 = reshape(uint32((25:36)),3,4);
    expdata(2).field2 = reshape(uint32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1712: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1712"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1712"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_516
#AT_START_517
at_fn_group_banner 517 'mat5_compressed_write.at:1715' \
  "Write structure array with 2D 16-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "517. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1716" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1716"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1718: \$builddir/test_mat -v 5 -z -c int16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int16 write_struct_2d_numeric" "mat5_compressed_write.at:1718"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1718"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1769: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1769"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1769"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1770" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1770"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12)),3,4);
    expdata(1).field2 = reshape(int16((13:24)),3,4);
    expdata(2).field1 = reshape(int16((25:36)),3,4);
    expdata(2).field2 = reshape(int16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1795: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1795"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1795"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_517
#AT_START_518
at_fn_group_banner 518 'mat5_compressed_write.at:1798' \
  "Write structure array with 2D 16-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "518. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1799" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1799"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1801: \$builddir/test_mat -v 5 -z -c uint16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint16 write_struct_2d_numeric" "mat5_compressed_write.at:1801"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1801"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1852: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1852"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1852"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1853" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1853"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12)),3,4);
    expdata(1).field2 = reshape(uint16((13:24)),3,4);
    expdata(2).field1 = reshape(uint16((25:36)),3,4);
    expdata(2).field2 = reshape(uint16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1878: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1878"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1878"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_518
#AT_START_519
at_fn_group_banner 519 'mat5_compressed_write.at:1881' \
  "Write structure array with 2D 8-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "519. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1882" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1882"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1884: \$builddir/test_mat -v 5 -z -c int8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int8 write_struct_2d_numeric" "mat5_compressed_write.at:1884"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1884"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1935: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:1935"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1935"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:1936" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1936"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12)),3,4);
    expdata(1).field2 = reshape(int8((13:24)),3,4);
    expdata(2).field1 = reshape(int8((25:36)),3,4);
    expdata(2).field2 = reshape(int8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1961: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:1961"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1961"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_519
#AT_START_520
at_fn_group_banner 520 'mat5_compressed_write.at:1964' \
  "Write structure array with 2D 8-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "520. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:1965" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:1965"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:1967: \$builddir/test_mat -v 5 -z -c uint8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint8 write_struct_2d_numeric" "mat5_compressed_write.at:1967"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:1967"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2018: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat5_compressed_write.at:2018"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2018"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2019" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2019"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12)),3,4);
    expdata(1).field2 = reshape(uint8((13:24)),3,4);
    expdata(2).field1 = reshape(uint8((25:36)),3,4);
    expdata(2).field2 = reshape(uint8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2044: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2044"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2044"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_520
#AT_START_521
at_fn_group_banner 521 'mat5_compressed_write.at:2047' \
  "Write structure array with 2D double-precision complex fields" "" 10
at_xfail=no
(
  $as_echo "521. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2048" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2048"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2050: \$builddir/test_mat -v 5 -z write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_struct_complex_2d_numeric" "mat5_compressed_write.at:2050"
( $at_check_trace; $builddir/test_mat -v 5 -z write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2050"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2101: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2101"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2101"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2102" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2102"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape((1:12) + j*(51:62),3,4);
    expdata(1).field2 = reshape((13:24) + j*(63:74),3,4);
    expdata(2).field1 = reshape((25:36) + j*(75:86),3,4);
    expdata(2).field2 = reshape((37:48) + j*(87:98),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2127: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2127"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2127"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_521
#AT_START_522
at_fn_group_banner 522 'mat5_compressed_write.at:2130' \
  "Write structure array with 2D single-precision complex fields" "" 10
at_xfail=no
(
  $as_echo "522. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2131" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2131"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2133: \$builddir/test_mat -v 5 -z -c single write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c single write_struct_complex_2d_numeric" "mat5_compressed_write.at:2133"
( $at_check_trace; $builddir/test_mat -v 5 -z -c single write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2133"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2184: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2184"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2184"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2185" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2185"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(single((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(single((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(single((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2210: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2210"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2210"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_522
#AT_START_523
at_fn_group_banner 523 'mat5_compressed_write.at:2213' \
  "Write structure array with 2D 64-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "523. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2214" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2214"
$as_echo "mat5_compressed_write.at:2215" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2215"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2217: \$builddir/test_mat -v 5 -z -c int64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int64 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2217"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2217"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2268: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2268"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2268"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2269" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2269"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2294: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2294"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2294"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_523
#AT_START_524
at_fn_group_banner 524 'mat5_compressed_write.at:2297' \
  "Write structure array with 2D 64-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "524. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2298" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2298"
$as_echo "mat5_compressed_write.at:2299" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2299"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2301: \$builddir/test_mat -v 5 -z -c uint64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint64 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2301"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2301"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2352: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2352"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2352"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2353" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2353"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2378: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2378"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2378"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_524
#AT_START_525
at_fn_group_banner 525 'mat5_compressed_write.at:2381' \
  "Write structure array with 2D 32-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "525. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2382" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2382"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2384: \$builddir/test_mat -v 5 -z -c int32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int32 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2384"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2384"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2435: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2435"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2435"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2436" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2436"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2461: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2461"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2461"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_525
#AT_START_526
at_fn_group_banner 526 'mat5_compressed_write.at:2464' \
  "Write structure array with 2D 32-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "526. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2465" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2465"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2467: \$builddir/test_mat -v 5 -z -c uint32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint32 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2467"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2467"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2518: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2518"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2518"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2519" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2519"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2544: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2544"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2544"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_526
#AT_START_527
at_fn_group_banner 527 'mat5_compressed_write.at:2547' \
  "Write structure array with 2D 16-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "527. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2548" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2548"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2550: \$builddir/test_mat -v 5 -z -c int16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int16 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2550"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2550"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2601: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2601"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2601"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2602" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2602"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2627: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2627"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2627"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_527
#AT_START_528
at_fn_group_banner 528 'mat5_compressed_write.at:2630' \
  "Write structure array with 2D 16-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "528. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2631" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2631"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2633: \$builddir/test_mat -v 5 -z -c uint16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint16 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2633"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2633"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2684: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2684"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2684"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2685" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2685"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2710: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2710"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2710"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_528
#AT_START_529
at_fn_group_banner 529 'mat5_compressed_write.at:2713' \
  "Write structure array with 2D 8-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "529. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2714" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2714"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2716: \$builddir/test_mat -v 5 -z -c int8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int8 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2716"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2716"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2767: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2767"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2767"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2768" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2768"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2793: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2793"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2793"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_529
#AT_START_530
at_fn_group_banner 530 'mat5_compressed_write.at:2796' \
  "Write structure array with 2D 8-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "530. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2797" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2797"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2799: \$builddir/test_mat -v 5 -z -c uint8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint8 write_struct_complex_2d_numeric" "mat5_compressed_write.at:2799"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2799"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2850: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat5_compressed_write.at:2850"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2850"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2851" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2851"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2876: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2876"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2876"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_530
#AT_START_531
at_fn_group_banner 531 'mat5_compressed_write.at:2879' \
  "Write empty cell array" "                         " 10
at_xfail=no
(
  $as_echo "531. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2880" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2880"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2881: \$builddir/test_mat -v 5 -z write_empty_cell"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_empty_cell" "mat5_compressed_write.at:2881"
( $at_check_trace; $builddir/test_mat -v 5 -z write_empty_cell
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2881"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2892: \$builddir/test_mat readvar test_write_empty_cell.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var1" "mat5_compressed_write.at:2892"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2892"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2909: \$builddir/test_mat readvar test_write_empty_cell.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var2" "mat5_compressed_write.at:2909"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2909"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2910" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2910"
cat >test_write_empty_cell.m <<'_ATEOF'

try
    load test_write_empty_cell.mat
    expdata1 = cell(0,1);
    expdata2 = {zeros(0,1);zeros(0,1)};
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2930: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:2930"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2930"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_531
#AT_START_532
at_fn_group_banner 532 'mat5_compressed_write.at:2933' \
  "Write cell array with 2D double-precision fields" "" 10
at_xfail=no
(
  $as_echo "532. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:2934" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2934"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2936: \$builddir/test_mat -v 5 -z write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_cell_2d_numeric" "mat5_compressed_write.at:2936"
( $at_check_trace; $builddir/test_mat -v 5 -z write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2936"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:2983: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:2983"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:2983"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:2984" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:2984"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape((1:12),3,4);reshape((13:24),3,4);...
               reshape((25:36),3,4);reshape((37:48),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3007: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3007"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3007"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_532
#AT_START_533
at_fn_group_banner 533 'mat5_compressed_write.at:3010' \
  "Write cell array with 2D single-precision fields" "" 10
at_xfail=no
(
  $as_echo "533. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3011" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3011"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3013: \$builddir/test_mat -v 5 -z -c single write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c single write_cell_2d_numeric" "mat5_compressed_write.at:3013"
( $at_check_trace; $builddir/test_mat -v 5 -z -c single write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3013"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3060: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3060"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3060"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3061" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3061"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(single((1:12)),3,4);reshape(single((13:24)),3,4);...
               reshape(single((25:36)),3,4);reshape(single((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3084: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3084"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3084"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_533
#AT_START_534
at_fn_group_banner 534 'mat5_compressed_write.at:3087' \
  "Write cell array with 2D 64-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "534. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3088" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3088"
$as_echo "mat5_compressed_write.at:3089" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3089"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3091: \$builddir/test_mat -v 5 -z -c int64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int64 write_cell_2d_numeric" "mat5_compressed_write.at:3091"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3091"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3138: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3138"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3138"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3139" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3139"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int64((1:12)),3,4);reshape(int64((13:24)),3,4);...
               reshape(int64((25:36)),3,4);reshape(int64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3162: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3162"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3162"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_534
#AT_START_535
at_fn_group_banner 535 'mat5_compressed_write.at:3165' \
  "Write cell array with 2D 64-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "535. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3166" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3166"
$as_echo "mat5_compressed_write.at:3167" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3167"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3169: \$builddir/test_mat -v 5 -z -c uint64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint64 write_cell_2d_numeric" "mat5_compressed_write.at:3169"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3169"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3216: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3216"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3216"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3217" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3217"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint64((1:12)),3,4);reshape(uint64((13:24)),3,4);...
               reshape(uint64((25:36)),3,4);reshape(uint64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3240: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3240"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3240"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_535
#AT_START_536
at_fn_group_banner 536 'mat5_compressed_write.at:3243' \
  "Write cell array with 2D 32-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "536. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3244" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3244"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3246: \$builddir/test_mat -v 5 -z -c int32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int32 write_cell_2d_numeric" "mat5_compressed_write.at:3246"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3246"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3293: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3293"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3293"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3294" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3294"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int32((1:12)),3,4);reshape(int32((13:24)),3,4);...
               reshape(int32((25:36)),3,4);reshape(int32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3317: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3317"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3317"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_536
#AT_START_537
at_fn_group_banner 537 'mat5_compressed_write.at:3320' \
  "Write cell array with 2D 32-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "537. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3321" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3321"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3323: \$builddir/test_mat -v 5 -z -c uint32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint32 write_cell_2d_numeric" "mat5_compressed_write.at:3323"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3323"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3370: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3370"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3370"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3371" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3371"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint32((1:12)),3,4);reshape(uint32((13:24)),3,4);...
               reshape(uint32((25:36)),3,4);reshape(uint32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3394: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3394"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3394"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_537
#AT_START_538
at_fn_group_banner 538 'mat5_compressed_write.at:3397' \
  "Write cell array with 2D 16-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "538. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3398" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3398"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3400: \$builddir/test_mat -v 5 -z -c int16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int16 write_cell_2d_numeric" "mat5_compressed_write.at:3400"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3400"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3447: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3447"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3447"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3448" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3448"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int16((1:12)),3,4);reshape(int16((13:24)),3,4);...
               reshape(int16((25:36)),3,4);reshape(int16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3471: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3471"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3471"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_538
#AT_START_539
at_fn_group_banner 539 'mat5_compressed_write.at:3474' \
  "Write cell array with 2D 16-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "539. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3475" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3475"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3477: \$builddir/test_mat -v 5 -z -c uint16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint16 write_cell_2d_numeric" "mat5_compressed_write.at:3477"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3477"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3524: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3524"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3524"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3525" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3525"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint16((1:12)),3,4);reshape(uint16((13:24)),3,4);...
               reshape(uint16((25:36)),3,4);reshape(uint16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3548: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3548"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3548"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_539
#AT_START_540
at_fn_group_banner 540 'mat5_compressed_write.at:3551' \
  "Write cell array with 2D 8-bit signed integer fields" "" 10
at_xfail=no
(
  $as_echo "540. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3552" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3552"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3554: \$builddir/test_mat -v 5 -z -c int8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int8 write_cell_2d_numeric" "mat5_compressed_write.at:3554"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3554"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3601: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3601"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3601"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3602" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3602"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int8((1:12)),3,4);reshape(int8((13:24)),3,4);...
               reshape(int8((25:36)),3,4);reshape(int8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3625: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3625"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3625"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_540
#AT_START_541
at_fn_group_banner 541 'mat5_compressed_write.at:3628' \
  "Write cell array with 2D 8-bit unsigned integer fields" "" 10
at_xfail=no
(
  $as_echo "541. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3629" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3629"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3631: \$builddir/test_mat -v 5 -z -c uint8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint8 write_cell_2d_numeric" "mat5_compressed_write.at:3631"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3631"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3678: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat5_compressed_write.at:3678"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3678"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3679" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3679"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint8((1:12)),3,4);reshape(uint8((13:24)),3,4);...
               reshape(uint8((25:36)),3,4);reshape(uint8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3702: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3702"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3702"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_541
#AT_START_542
at_fn_group_banner 542 'mat5_compressed_write.at:3705' \
  "Write cell array with 2D double-precision complex fields" "" 10
at_xfail=no
(
  $as_echo "542. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3706" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3706"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3708: \$builddir/test_mat -v 5 -z write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z write_cell_complex_2d_numeric" "mat5_compressed_write.at:3708"
( $at_check_trace; $builddir/test_mat -v 5 -z write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3708"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3755: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:3755"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3755"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3756" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3756"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape((1:12)+j*(51:62),3,4);...
               reshape((13:24)+j*(63:74),3,4);...
               reshape((25:36)+j*(75:86),3,4);...
               reshape((37:48)+j*(87:98),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3781: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3781"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3781"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_542
#AT_START_543
at_fn_group_banner 543 'mat5_compressed_write.at:3784' \
  "Write cell array with 2D single-precision complex fields" "" 10
at_xfail=no
(
  $as_echo "543. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3785" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3785"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3787: \$builddir/test_mat -v 5 -z -c single write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c single write_cell_complex_2d_numeric" "mat5_compressed_write.at:3787"
( $at_check_trace; $builddir/test_mat -v 5 -z -c single write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3787"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3834: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:3834"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3834"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3835" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3835"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(single((1:12)+j*(51:62)),3,4);...
               reshape(single((13:24)+j*(63:74)),3,4);...
               reshape(single((25:36)+j*(75:86)),3,4);...
               reshape(single((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3860: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3860"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3860"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_543
#AT_START_544
at_fn_group_banner 544 'mat5_compressed_write.at:3863' \
  "Write cell array with 2D 64-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "544. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3864" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3864"
$as_echo "mat5_compressed_write.at:3865" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3865"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3867: \$builddir/test_mat -v 5 -z -c int64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int64 write_cell_complex_2d_numeric" "mat5_compressed_write.at:3867"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3867"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3914: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:3914"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3914"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3915" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3915"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int64((1:12)+j*(51:62)),3,4);...
               reshape(int64((13:24)+j*(63:74)),3,4);...
               reshape(int64((25:36)+j*(75:86)),3,4);...
               reshape(int64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3940: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:3940"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3940"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_544
#AT_START_545
at_fn_group_banner 545 'mat5_compressed_write.at:3943' \
  "Write cell array with 2D 64-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "545. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:3944" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3944"
$as_echo "mat5_compressed_write.at:3945" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3945"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3947: \$builddir/test_mat -v 5 -z -c uint64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint64 write_cell_complex_2d_numeric" "mat5_compressed_write.at:3947"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3947"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:3994: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:3994"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:3994"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:3995" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:3995"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint64((1:12)+j*(51:62)),3,4);...
               reshape(uint64((13:24)+j*(63:74)),3,4);...
               reshape(uint64((25:36)+j*(75:86)),3,4);...
               reshape(uint64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4020: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4020"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4020"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_545
#AT_START_546
at_fn_group_banner 546 'mat5_compressed_write.at:4023' \
  "Write cell array with 2D 32-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "546. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:4024" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4024"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4026: \$builddir/test_mat -v 5 -z -c int32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int32 write_cell_complex_2d_numeric" "mat5_compressed_write.at:4026"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4026"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4073: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:4073"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4073"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:4074" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4074"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int32((1:12)+j*(51:62)),3,4);...
               reshape(int32((13:24)+j*(63:74)),3,4);...
               reshape(int32((25:36)+j*(75:86)),3,4);...
               reshape(int32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4099: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4099"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4099"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_546
#AT_START_547
at_fn_group_banner 547 'mat5_compressed_write.at:4102' \
  "Write cell array with 2D 32-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "547. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:4103" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4103"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4105: \$builddir/test_mat -v 5 -z -c uint32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint32 write_cell_complex_2d_numeric" "mat5_compressed_write.at:4105"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4105"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4152: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:4152"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4152"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:4153" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4153"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint32((1:12)+j*(51:62)),3,4);...
               reshape(uint32((13:24)+j*(63:74)),3,4);...
               reshape(uint32((25:36)+j*(75:86)),3,4);...
               reshape(uint32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4178: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4178"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4178"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_547
#AT_START_548
at_fn_group_banner 548 'mat5_compressed_write.at:4181' \
  "Write cell array with 2D 16-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "548. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:4182" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4182"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4184: \$builddir/test_mat -v 5 -z -c int16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int16 write_cell_complex_2d_numeric" "mat5_compressed_write.at:4184"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4184"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4231: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:4231"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4231"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:4232" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4232"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int16((1:12)+j*(51:62)),3,4);...
               reshape(int16((13:24)+j*(63:74)),3,4);...
               reshape(int16((25:36)+j*(75:86)),3,4);...
               reshape(int16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4257: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4257"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4257"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_548
#AT_START_549
at_fn_group_banner 549 'mat5_compressed_write.at:4260' \
  "Write cell array with 2D 16-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "549. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:4261" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4261"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4263: \$builddir/test_mat -v 5 -z -c uint16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint16 write_cell_complex_2d_numeric" "mat5_compressed_write.at:4263"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4263"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4310: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:4310"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4310"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:4311" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4311"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint16((1:12)+j*(51:62)),3,4);...
               reshape(uint16((13:24)+j*(63:74)),3,4);...
               reshape(uint16((25:36)+j*(75:86)),3,4);...
               reshape(uint16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4336: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4336"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4336"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_549
#AT_START_550
at_fn_group_banner 550 'mat5_compressed_write.at:4339' \
  "Write cell array with 2D 8-bit signed integer complex fields" "" 10
at_xfail=no
(
  $as_echo "550. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:4340" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4340"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4342: \$builddir/test_mat -v 5 -z -c int8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c int8 write_cell_complex_2d_numeric" "mat5_compressed_write.at:4342"
( $at_check_trace; $builddir/test_mat -v 5 -z -c int8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4342"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4389: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:4389"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4389"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:4390" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4390"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int8((1:12)+j*(51:62)),3,4);...
               reshape(int8((13:24)+j*(63:74)),3,4);...
               reshape(int8((25:36)+j*(75:86)),3,4);...
               reshape(int8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4415: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4415"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4415"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_550
#AT_START_551
at_fn_group_banner 551 'mat5_compressed_write.at:4418' \
  "Write cell array with 2D 8-bit unsigned integer complex fields" "" 10
at_xfail=no
(
  $as_echo "551. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat5_compressed_write.at:4419" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4419"
{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4421: \$builddir/test_mat -v 5 -z -c uint8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 5 -z -c uint8 write_cell_complex_2d_numeric" "mat5_compressed_write.at:4421"
( $at_check_trace; $builddir/test_mat -v 5 -z -c uint8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4421"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4468: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat5_compressed_write.at:4468"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4468"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat5_compressed_write.at:4469" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat5_compressed_write.at:4469"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint8((1:12)+j*(51:62)),3,4);...
               reshape(uint8((13:24)+j*(63:74)),3,4);...
               reshape(uint8((25:36)+j*(75:86)),3,4);...
               reshape(uint8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat5_compressed_write.at:4494: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat5_compressed_write.at:4494"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat5_compressed_write.at:4494"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_551
#AT_START_552
at_fn_group_banner 552 'mat73_write.at:27' \
  "Write 2D double-precision array" "                " 11
at_xfail=no
(
  $as_echo "552. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:28" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:28"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:30: \$builddir/test_mat -v 7.3 -c double write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c double write_2d_numeric" "mat73_write.at:30"
( $at_check_trace; $builddir/test_mat -v 7.3 -c double write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:30"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:46: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:46"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:46"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:47" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:47"
cat >test_write_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:67: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:67"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:67"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_552
#AT_START_553
at_fn_group_banner 553 'mat73_write.at:70' \
  "Write 2D single-precision array" "                " 11
at_xfail=no
(
  $as_echo "553. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:71" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:71"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:73: \$builddir/test_mat -v 7.3 -c single write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c single write_2d_numeric" "mat73_write.at:73"
( $at_check_trace; $builddir/test_mat -v 7.3 -c single write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:73"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:89: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:89"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:89"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:90" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:90"
cat >test_write_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = single(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:110: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:110"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:110"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_553
#AT_START_554
at_fn_group_banner 554 'mat73_write.at:113' \
  "Write 2D 64-bit integer array" "                  " 11
at_xfail=no
(
  $as_echo "554. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:114" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:114"
$as_echo "mat73_write.at:115" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:115"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:117: \$builddir/test_mat -v 7.3 -c int64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int64 write_2d_numeric" "mat73_write.at:117"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:117"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:133: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:133"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:133"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:134" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:134"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:154: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:154"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:154"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_554
#AT_START_555
at_fn_group_banner 555 'mat73_write.at:157' \
  "Write 2D 64-bit unsigned integer array" "         " 11
at_xfail=no
(
  $as_echo "555. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:158" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:158"
$as_echo "mat73_write.at:159" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:159"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:161: \$builddir/test_mat -v 7.3 -c uint64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint64 write_2d_numeric" "mat73_write.at:161"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:161"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:177: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:177"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:177"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:178" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:178"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:198: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:198"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:198"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_555
#AT_START_556
at_fn_group_banner 556 'mat73_write.at:201' \
  "Write 2D 32-bit integer array" "                  " 11
at_xfail=no
(
  $as_echo "556. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:202" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:202"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:204: \$builddir/test_mat -v 7.3 -c int32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int32 write_2d_numeric" "mat73_write.at:204"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:204"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:220: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:220"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:220"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:221" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:221"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:241: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:241"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:241"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_556
#AT_START_557
at_fn_group_banner 557 'mat73_write.at:244' \
  "Write 2D 32-bit unsigned integer array" "         " 11
at_xfail=no
(
  $as_echo "557. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:245" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:245"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:247: \$builddir/test_mat -v 7.3 -c uint32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint32 write_2d_numeric" "mat73_write.at:247"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:247"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:263: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:263"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:263"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:264" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:264"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:284: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:284"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:284"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_557
#AT_START_558
at_fn_group_banner 558 'mat73_write.at:287' \
  "Write 2D 16-bit integer array" "                  " 11
at_xfail=no
(
  $as_echo "558. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:288" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:288"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:290: \$builddir/test_mat -v 7.3 -c int16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int16 write_2d_numeric" "mat73_write.at:290"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:290"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:306: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:306"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:306"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:307" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:307"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:327: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:327"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:327"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_558
#AT_START_559
at_fn_group_banner 559 'mat73_write.at:330' \
  "Write 2D 16-bit unsigned integer array" "         " 11
at_xfail=no
(
  $as_echo "559. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:331" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:331"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:333: \$builddir/test_mat -v 7.3 -c uint16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint16 write_2d_numeric" "mat73_write.at:333"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:333"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:349: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:349"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:349"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:350" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:350"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:370: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:370"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:370"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_559
#AT_START_560
at_fn_group_banner 560 'mat73_write.at:373' \
  "Write 2D 8-bit integer array" "                   " 11
at_xfail=no
(
  $as_echo "560. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:374" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:374"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:376: \$builddir/test_mat -v 7.3 -c int8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int8 write_2d_numeric" "mat73_write.at:376"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:376"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:392: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:392"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:392"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:393" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:393"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:413: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:413"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:413"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_560
#AT_START_561
at_fn_group_banner 561 'mat73_write.at:416' \
  "Write 2D 8-bit unsigned integer array" "          " 11
at_xfail=no
(
  $as_echo "561. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:417" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:417"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:419: \$builddir/test_mat -v 7.3 -c uint8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint8 write_2d_numeric" "mat73_write.at:419"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:419"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:435: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_write.at:435"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:435"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:436" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:436"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:456: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:456"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:456"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_561
#AT_START_562
at_fn_group_banner 562 'mat73_write.at:459' \
  "Write 2D double-precision complex array" "        " 11
at_xfail=no
(
  $as_echo "562. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:460" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:460"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:462: \$builddir/test_mat -v 7.3 -c double write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c double write_complex_2d_numeric" "mat73_write.at:462"
( $at_check_trace; $builddir/test_mat -v 7.3 -c double write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:462"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:478: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:478"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:478"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:479" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:479"
cat >test_write_complex_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:499: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:499"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:499"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_562
#AT_START_563
at_fn_group_banner 563 'mat73_write.at:502' \
  "Write 2D single-precision complex array" "        " 11
at_xfail=no
(
  $as_echo "563. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:503" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:503"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:505: \$builddir/test_mat -v 7.3 -c single write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c single write_complex_2d_numeric" "mat73_write.at:505"
( $at_check_trace; $builddir/test_mat -v 7.3 -c single write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:505"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:521: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:521"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:521"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:522" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:522"
cat >test_write_complex_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = single(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:542: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:542"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:542"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_563
#AT_START_564
at_fn_group_banner 564 'mat73_write.at:545' \
  "Write 2D 64-bit integer complex array" "          " 11
at_xfail=no
(
  $as_echo "564. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:546" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:546"
$as_echo "mat73_write.at:547" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:547"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:549: \$builddir/test_mat -v 7.3 -c int64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int64 write_complex_2d_numeric" "mat73_write.at:549"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:549"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:565: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:565"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:565"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:566" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:566"
cat >test_write_complex_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:586: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:586"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:586"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_564
#AT_START_565
at_fn_group_banner 565 'mat73_write.at:589' \
  "Write 2D 64-bit unsigned integer complex array" " " 11
at_xfail=no
(
  $as_echo "565. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:590" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:590"
$as_echo "mat73_write.at:591" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:591"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:593: \$builddir/test_mat -v 7.3 -c uint64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint64 write_complex_2d_numeric" "mat73_write.at:593"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:593"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:609: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:609"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:609"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:610" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:610"
cat >test_write_complex_2d_numeric_uint64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:630: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:630"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:630"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_565
#AT_START_566
at_fn_group_banner 566 'mat73_write.at:633' \
  "Write 2D 32-bit integer complex array" "          " 11
at_xfail=no
(
  $as_echo "566. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:634" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:634"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:636: \$builddir/test_mat -v 7.3 -c int32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int32 write_complex_2d_numeric" "mat73_write.at:636"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:636"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:652: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:652"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:652"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:653" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:653"
cat >test_write_complex_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:673: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:673"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:673"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_566
#AT_START_567
at_fn_group_banner 567 'mat73_write.at:676' \
  "Write 2D 32-bit unsigned integer complex array" " " 11
at_xfail=no
(
  $as_echo "567. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:677" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:677"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:679: \$builddir/test_mat -v 7.3 -c uint32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint32 write_complex_2d_numeric" "mat73_write.at:679"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:679"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:695: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:695"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:695"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:696" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:696"
cat >test_write_complex_2d_numeric_uint32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:716: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:716"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:716"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_567
#AT_START_568
at_fn_group_banner 568 'mat73_write.at:719' \
  "Write 2D 16-bit integer complex array" "          " 11
at_xfail=no
(
  $as_echo "568. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:720" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:720"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:722: \$builddir/test_mat -v 7.3 -c int16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int16 write_complex_2d_numeric" "mat73_write.at:722"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:722"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:738: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:738"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:738"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:739" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:739"
cat >test_write_complex_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:759: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:759"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:759"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_568
#AT_START_569
at_fn_group_banner 569 'mat73_write.at:762' \
  "Write 2D 16-bit unsigned integer complex array" " " 11
at_xfail=no
(
  $as_echo "569. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:763" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:763"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:765: \$builddir/test_mat -v 7.3 -c uint16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint16 write_complex_2d_numeric" "mat73_write.at:765"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:765"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:781: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:781"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:781"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:782" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:782"
cat >test_write_complex_2d_numeric_uint16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:802: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:802"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:802"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_569
#AT_START_570
at_fn_group_banner 570 'mat73_write.at:805' \
  "Write 2D 8-bit integer complex array" "           " 11
at_xfail=no
(
  $as_echo "570. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:806" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:806"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:808: \$builddir/test_mat -v 7.3 -c int8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int8 write_complex_2d_numeric" "mat73_write.at:808"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:808"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:824: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:824"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:824"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:825" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:825"
cat >test_write_complex_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:845: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:845"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:845"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_570
#AT_START_571
at_fn_group_banner 571 'mat73_write.at:848' \
  "Write 2D 8-bit unsigned integer complex array" "  " 11
at_xfail=no
(
  $as_echo "571. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:849" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:849"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:851: \$builddir/test_mat -v 7.3 -c uint8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint8 write_complex_2d_numeric" "mat73_write.at:851"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:851"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:867: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_write.at:867"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:867"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:868" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:868"
cat >test_write_complex_2d_numeric_uint8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:888: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:888"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:888"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_571
#AT_START_572
at_fn_group_banner 572 'mat73_write.at:891' \
  "Write 2D sparse double-precision array" "         " 11
at_xfail=no
(
  $as_echo "572. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:892" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:892"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:894: \$builddir/test_mat -v 7.3 -c double write_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c double write_sparse" "mat73_write.at:894"
( $at_check_trace; $builddir/test_mat -v 7.3 -c double write_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:894"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (5,1)  5
    (2,2)  7
    (3,2)  8
    (4,2)  9
    (1,3)  11
    (5,3)  15
    (2,4)  17
    (3,4)  18
    (4,4)  19
    (1,5)  21
    (5,5)  25
    (2,6)  27
    (3,6)  28
    (4,6)  29
    (1,7)  31
    (5,7)  35
    (2,8)  37
    (3,8)  38
    (4,8)  39
    (1,9)  41
    (5,9)  45
    (2,10)  47
    (3,10)  48
    (4,10)  49
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:930: \$builddir/test_mat readvar test_write_sparse.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse.mat sparse_matrix" "mat73_write.at:930"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:930"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:931" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:931"
cat >test_write_sparse_double.m <<'_ATEOF'

try
    load test_write_sparse.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:955: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:955"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:955"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_572
#AT_START_573
at_fn_group_banner 573 'mat73_write.at:958' \
  "Write 2D sparse complex double-precision array" " " 11
at_xfail=no
(
  $as_echo "573. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:959" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:959"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:961: \$builddir/test_mat -v 7.3 -c double write_complex_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c double write_complex_sparse" "mat73_write.at:961"
( $at_check_trace; $builddir/test_mat -v 7.3 -c double write_complex_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:961"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 51i
    (5,1)  5 + 55i
    (2,2)  7 + 57i
    (3,2)  8 + 58i
    (4,2)  9 + 59i
    (1,3)  11 + 61i
    (5,3)  15 + 65i
    (2,4)  17 + 67i
    (3,4)  18 + 68i
    (4,4)  19 + 69i
    (1,5)  21 + 71i
    (5,5)  25 + 75i
    (2,6)  27 + 77i
    (3,6)  28 + 78i
    (4,6)  29 + 79i
    (1,7)  31 + 81i
    (5,7)  35 + 85i
    (2,8)  37 + 87i
    (3,8)  38 + 88i
    (4,8)  39 + 89i
    (1,9)  41 + 91i
    (5,9)  45 + 95i
    (2,10)  47 + 97i
    (3,10)  48 + 98i
    (4,10)  49 + 99i
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:997: \$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix" "mat73_write.at:997"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:997"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:998" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:998"
cat >test_write_sparse_complex_double.m <<'_ATEOF'

try
    load test_write_sparse_complex.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1022: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1022"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1022"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_573
#AT_START_574
at_fn_group_banner 574 'mat73_write.at:1025' \
  "Write 2D empty array" "                           " 11
at_xfail=no
(
  $as_echo "574. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1026" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1026"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1028: \$builddir/test_mat -v 7.3 -c double write_empty_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c double write_empty_2d_numeric" "mat73_write.at:1028"
( $at_check_trace; $builddir/test_mat -v 7.3 -c double write_empty_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1028"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: empty
      Rank: 2
Dimensions: 0 x 10
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1037: \$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty" "mat73_write.at:1037"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_2d_numeric.mat empty
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1037"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1038" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1038"
cat >test_write_empty.m <<'_ATEOF'

try
    load test_write_empty_2d_numeric.mat
    expdata = zeros(0,10);
    pass = true;
    pass = pass && isa(empty,class(expdata));
    pass = pass && isempty(empty);
    pass = pass && all(size(empty)==size(expdata));
    pass = pass && all(empty(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1059: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1059"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1059"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_574
#AT_START_575
at_fn_group_banner 575 'mat73_write.at:1062' \
  "Write character array" "                          " 11
at_xfail=no
(
  $as_echo "575. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1063" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1063"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1064: \$builddir/test_mat -v 7.3 write_char"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_char" "mat73_write.at:1064"
( $at_check_trace; $builddir/test_mat -v 7.3 write_char
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1064"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#$%^&*()-_=+`~
[{]}\|;:'",<.>/?          
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1079: \$builddir/test_mat readvar test_write_char.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_char.mat a" "mat73_write.at:1079"
( $at_check_trace; $builddir/test_mat readvar test_write_char.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1079"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1080" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1080"
cat >test_write_char.m <<'_ATEOF'

try
    load test_write_char.mat
    expdata = ['abcdefghijklmnopqrstuvwxyz';
               'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
               '1234567890!@#$%^&*()-_=+`~';
               '[{]}\|;:''",<.>/?          '];
    pass = true;
    pass = pass && isequal(expdata,a);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1101: \$MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1101"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1101"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_575
#AT_START_576
at_fn_group_banner 576 'mat73_write.at:1104' \
  "Write empty structure array" "                    " 11
at_xfail=no
(
  $as_echo "576. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1105" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1105"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1107: \$builddir/test_mat -v 7.3 write_empty_struct"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_empty_struct" "mat73_write.at:1107"
( $at_check_trace; $builddir/test_mat -v 7.3 write_empty_struct
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1107"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1118: \$builddir/test_mat readvar test_write_empty_struct.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var1" "mat73_write.at:1118"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1118"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1133: \$builddir/test_mat readvar test_write_empty_struct.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var2" "mat73_write.at:1133"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1133"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var3
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1154: \$builddir/test_mat readvar test_write_empty_struct.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var3" "mat73_write.at:1154"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1154"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var4
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1189: \$builddir/test_mat readvar test_write_empty_struct.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var4" "mat73_write.at:1189"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1189"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1190" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1190"
cat >test_write_empty_struct.m <<'_ATEOF'

try
    load test_write_empty_struct.mat
    expdata1 = repmat(struct,0,1);
    expdata2 = repmat(struct('field1',zeros(0,0),'field2',zeros(0,0)),0,1);
    expdata3 = struct('field1',zeros(0,1),'field2',zeros(0,1));
    expdata4(1).field1 = zeros(0,1);
    expdata4(1).field2 = repmat(' ',0,1);
    expdata4(2).field1 = repmat(struct,0,1);
    expdata4(2).field2 = repmat({zeros(0,0)},0,1);
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
    pass = pass && isequal(var3,expdata3);
    pass = pass && isequal(var4,expdata4(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1217: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1217"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1217"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_576
#AT_START_577
at_fn_group_banner 577 'mat73_write.at:1220' \
  "Write structure array with 2D double-precision fields" "" 11
at_xfail=no
(
  $as_echo "577. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1221" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1221"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1223: \$builddir/test_mat -v 7.3 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_struct_2d_numeric" "mat73_write.at:1223"
( $at_check_trace; $builddir/test_mat -v 7.3 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1223"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1274: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1274"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1274"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1275" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1275"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape((1:12),3,4);
    expdata(1).field2 = reshape((13:24),3,4);
    expdata(2).field1 = reshape((25:36),3,4);
    expdata(2).field2 = reshape((37:48),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1300: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1300"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1300"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_577
#AT_START_578
at_fn_group_banner 578 'mat73_write.at:1303' \
  "Write structure array with 2D single-precision fields" "" 11
at_xfail=no
(
  $as_echo "578. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1304" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1304"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1306: \$builddir/test_mat -v 7.3 -c single write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c single write_struct_2d_numeric" "mat73_write.at:1306"
( $at_check_trace; $builddir/test_mat -v 7.3 -c single write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1306"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1357: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1357"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1357"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1358" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1358"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12)),3,4);
    expdata(1).field2 = reshape(single((13:24)),3,4);
    expdata(2).field1 = reshape(single((25:36)),3,4);
    expdata(2).field2 = reshape(single((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1383: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1383"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1383"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_578
#AT_START_579
at_fn_group_banner 579 'mat73_write.at:1386' \
  "Write structure array with 2D 64-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "579. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1387" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1387"
$as_echo "mat73_write.at:1388" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1388"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1390: \$builddir/test_mat -v 7.3 -c int64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int64 write_struct_2d_numeric" "mat73_write.at:1390"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1390"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1441: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1441"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1441"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1442" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1442"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12)),3,4);
    expdata(1).field2 = reshape(int64((13:24)),3,4);
    expdata(2).field1 = reshape(int64((25:36)),3,4);
    expdata(2).field2 = reshape(int64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1467: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1467"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1467"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_579
#AT_START_580
at_fn_group_banner 580 'mat73_write.at:1470' \
  "Write structure array with 2D 64-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "580. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1471" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1471"
$as_echo "mat73_write.at:1472" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1472"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1474: \$builddir/test_mat -v 7.3 -c uint64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint64 write_struct_2d_numeric" "mat73_write.at:1474"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1474"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1525: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1525"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1525"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1526" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1526"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12)),3,4);
    expdata(1).field2 = reshape(uint64((13:24)),3,4);
    expdata(2).field1 = reshape(uint64((25:36)),3,4);
    expdata(2).field2 = reshape(uint64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1551: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1551"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1551"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_580
#AT_START_581
at_fn_group_banner 581 'mat73_write.at:1554' \
  "Write structure array with 2D 32-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "581. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1555" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1555"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1557: \$builddir/test_mat -v 7.3 -c int32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int32 write_struct_2d_numeric" "mat73_write.at:1557"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1557"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1608: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1608"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1608"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1609" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1609"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12)),3,4);
    expdata(1).field2 = reshape(int32((13:24)),3,4);
    expdata(2).field1 = reshape(int32((25:36)),3,4);
    expdata(2).field2 = reshape(int32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1634: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1634"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1634"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_581
#AT_START_582
at_fn_group_banner 582 'mat73_write.at:1637' \
  "Write structure array with 2D 32-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "582. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1638" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1638"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1640: \$builddir/test_mat -v 7.3 -c uint32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint32 write_struct_2d_numeric" "mat73_write.at:1640"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1640"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1691: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1691"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1691"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1692" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1692"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12)),3,4);
    expdata(1).field2 = reshape(uint32((13:24)),3,4);
    expdata(2).field1 = reshape(uint32((25:36)),3,4);
    expdata(2).field2 = reshape(uint32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1717: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1717"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1717"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_582
#AT_START_583
at_fn_group_banner 583 'mat73_write.at:1720' \
  "Write structure array with 2D 16-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "583. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1721" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1721"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1723: \$builddir/test_mat -v 7.3 -c int16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int16 write_struct_2d_numeric" "mat73_write.at:1723"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1723"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1774: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1774"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1774"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1775" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1775"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12)),3,4);
    expdata(1).field2 = reshape(int16((13:24)),3,4);
    expdata(2).field1 = reshape(int16((25:36)),3,4);
    expdata(2).field2 = reshape(int16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1800: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1800"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1800"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_583
#AT_START_584
at_fn_group_banner 584 'mat73_write.at:1803' \
  "Write structure array with 2D 16-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "584. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1804" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1804"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1806: \$builddir/test_mat -v 7.3 -c uint16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint16 write_struct_2d_numeric" "mat73_write.at:1806"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1806"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1857: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1857"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1857"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1858" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1858"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12)),3,4);
    expdata(1).field2 = reshape(uint16((13:24)),3,4);
    expdata(2).field1 = reshape(uint16((25:36)),3,4);
    expdata(2).field2 = reshape(uint16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1883: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1883"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1883"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_584
#AT_START_585
at_fn_group_banner 585 'mat73_write.at:1886' \
  "Write structure array with 2D 8-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "585. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1887" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1887"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1889: \$builddir/test_mat -v 7.3 -c int8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int8 write_struct_2d_numeric" "mat73_write.at:1889"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1889"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1940: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:1940"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1940"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:1941" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1941"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12)),3,4);
    expdata(1).field2 = reshape(int8((13:24)),3,4);
    expdata(2).field1 = reshape(int8((25:36)),3,4);
    expdata(2).field2 = reshape(int8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:1966: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:1966"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1966"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_585
#AT_START_586
at_fn_group_banner 586 'mat73_write.at:1969' \
  "Write structure array with 2D 8-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "586. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:1970" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:1970"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:1972: \$builddir/test_mat -v 7.3 -c uint8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint8 write_struct_2d_numeric" "mat73_write.at:1972"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:1972"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2023: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_write.at:2023"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2023"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2024" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2024"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12)),3,4);
    expdata(1).field2 = reshape(uint8((13:24)),3,4);
    expdata(2).field1 = reshape(uint8((25:36)),3,4);
    expdata(2).field2 = reshape(uint8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2049: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2049"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2049"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_586
#AT_START_587
at_fn_group_banner 587 'mat73_write.at:2052' \
  "Write structure array with 2D double-precision complex fields" "" 11
at_xfail=no
(
  $as_echo "587. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2053" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2053"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2055: \$builddir/test_mat -v 7.3 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_struct_complex_2d_numeric" "mat73_write.at:2055"
( $at_check_trace; $builddir/test_mat -v 7.3 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2055"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2106: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2106"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2106"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2107" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2107"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape((1:12) + j*(51:62),3,4);
    expdata(1).field2 = reshape((13:24) + j*(63:74),3,4);
    expdata(2).field1 = reshape((25:36) + j*(75:86),3,4);
    expdata(2).field2 = reshape((37:48) + j*(87:98),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2132: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2132"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2132"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_587
#AT_START_588
at_fn_group_banner 588 'mat73_write.at:2135' \
  "Write structure array with 2D single-precision complex fields" "" 11
at_xfail=no
(
  $as_echo "588. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2136" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2136"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2138: \$builddir/test_mat -v 7.3 -c single write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c single write_struct_complex_2d_numeric" "mat73_write.at:2138"
( $at_check_trace; $builddir/test_mat -v 7.3 -c single write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2138"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2189: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2189"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2189"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2190" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2190"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(single((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(single((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(single((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2215: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2215"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2215"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_588
#AT_START_589
at_fn_group_banner 589 'mat73_write.at:2218' \
  "Write structure array with 2D 64-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "589. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2219" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2219"
$as_echo "mat73_write.at:2220" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2220"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2222: \$builddir/test_mat -v 7.3 -c int64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int64 write_struct_complex_2d_numeric" "mat73_write.at:2222"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2222"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2273: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2273"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2273"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2274" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2274"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2299: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2299"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2299"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_589
#AT_START_590
at_fn_group_banner 590 'mat73_write.at:2302' \
  "Write structure array with 2D 64-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "590. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2303" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2303"
$as_echo "mat73_write.at:2304" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2304"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2306: \$builddir/test_mat -v 7.3 -c uint64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint64 write_struct_complex_2d_numeric" "mat73_write.at:2306"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2306"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2357: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2357"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2357"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2358" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2358"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2383: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2383"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2383"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_590
#AT_START_591
at_fn_group_banner 591 'mat73_write.at:2386' \
  "Write structure array with 2D 32-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "591. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2387" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2387"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2389: \$builddir/test_mat -v 7.3 -c int32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int32 write_struct_complex_2d_numeric" "mat73_write.at:2389"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2389"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2440: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2440"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2440"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2441" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2441"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2466: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2466"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2466"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_591
#AT_START_592
at_fn_group_banner 592 'mat73_write.at:2469' \
  "Write structure array with 2D 32-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "592. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2470" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2470"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2472: \$builddir/test_mat -v 7.3 -c uint32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint32 write_struct_complex_2d_numeric" "mat73_write.at:2472"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2472"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2523: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2523"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2523"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2524" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2524"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2549: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2549"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2549"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_592
#AT_START_593
at_fn_group_banner 593 'mat73_write.at:2552' \
  "Write structure array with 2D 16-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "593. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2553" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2553"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2555: \$builddir/test_mat -v 7.3 -c int16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int16 write_struct_complex_2d_numeric" "mat73_write.at:2555"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2555"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2606: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2606"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2606"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2607" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2607"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2632: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2632"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2632"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_593
#AT_START_594
at_fn_group_banner 594 'mat73_write.at:2635' \
  "Write structure array with 2D 16-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "594. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2636" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2636"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2638: \$builddir/test_mat -v 7.3 -c uint16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint16 write_struct_complex_2d_numeric" "mat73_write.at:2638"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2638"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2689: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2689"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2689"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2690" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2690"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2715: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2715"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2715"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_594
#AT_START_595
at_fn_group_banner 595 'mat73_write.at:2718' \
  "Write structure array with 2D 8-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "595. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2719" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2719"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2721: \$builddir/test_mat -v 7.3 -c int8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int8 write_struct_complex_2d_numeric" "mat73_write.at:2721"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2721"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2772: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2772"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2772"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2773" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2773"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2798: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2798"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2798"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_595
#AT_START_596
at_fn_group_banner 596 'mat73_write.at:2801' \
  "Write structure array with 2D 8-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "596. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2802" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2802"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2804: \$builddir/test_mat -v 7.3 -c uint8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint8 write_struct_complex_2d_numeric" "mat73_write.at:2804"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2804"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2855: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_write.at:2855"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2855"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2856" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2856"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2881: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2881"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2881"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_596
#AT_START_597
at_fn_group_banner 597 'mat73_write.at:2884' \
  "Write empty cell array" "                         " 11
at_xfail=no
(
  $as_echo "597. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2885" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2885"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2886: \$builddir/test_mat -v 7.3 write_empty_cell"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_empty_cell" "mat73_write.at:2886"
( $at_check_trace; $builddir/test_mat -v 7.3 write_empty_cell
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2886"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2897: \$builddir/test_mat readvar test_write_empty_cell.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var1" "mat73_write.at:2897"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2897"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2916: \$builddir/test_mat readvar test_write_empty_cell.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var2" "mat73_write.at:2916"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2916"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2917" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2917"
cat >test_write_empty_cell.m <<'_ATEOF'

try
    load test_write_empty_cell.mat
    expdata1 = cell(0,1);
    expdata2 = {zeros(0,1);zeros(0,1)};
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2937: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:2937"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2937"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_597
#AT_START_598
at_fn_group_banner 598 'mat73_write.at:2940' \
  "Write cell array with 2D double-precision fields" "" 11
at_xfail=no
(
  $as_echo "598. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:2941" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2941"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:2943: \$builddir/test_mat -v 7.3 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_cell_2d_numeric" "mat73_write.at:2943"
( $at_check_trace; $builddir/test_mat -v 7.3 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2943"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:2990: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:2990"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:2990"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:2991" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:2991"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape((1:12),3,4);reshape((13:24),3,4);...
               reshape((25:36),3,4);reshape((37:48),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3014: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3014"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3014"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_598
#AT_START_599
at_fn_group_banner 599 'mat73_write.at:3017' \
  "Write cell array with 2D single-precision fields" "" 11
at_xfail=no
(
  $as_echo "599. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3018" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3018"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3020: \$builddir/test_mat -v 7.3 -c single write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c single write_cell_2d_numeric" "mat73_write.at:3020"
( $at_check_trace; $builddir/test_mat -v 7.3 -c single write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3020"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3067: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3067"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3067"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3068" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3068"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(single((1:12)),3,4);reshape(single((13:24)),3,4);...
               reshape(single((25:36)),3,4);reshape(single((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3091: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3091"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3091"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_599
#AT_START_600
at_fn_group_banner 600 'mat73_write.at:3094' \
  "Write cell array with 2D 64-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "600. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3095" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3095"
$as_echo "mat73_write.at:3096" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3096"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3098: \$builddir/test_mat -v 7.3 -c int64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int64 write_cell_2d_numeric" "mat73_write.at:3098"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3098"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3145: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3145"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3145"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3146" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3146"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int64((1:12)),3,4);reshape(int64((13:24)),3,4);...
               reshape(int64((25:36)),3,4);reshape(int64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3169: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3169"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3169"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_600
#AT_START_601
at_fn_group_banner 601 'mat73_write.at:3172' \
  "Write cell array with 2D 64-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "601. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3173" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3173"
$as_echo "mat73_write.at:3174" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3174"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3176: \$builddir/test_mat -v 7.3 -c uint64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint64 write_cell_2d_numeric" "mat73_write.at:3176"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3176"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3223: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3223"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3223"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3224" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3224"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint64((1:12)),3,4);reshape(uint64((13:24)),3,4);...
               reshape(uint64((25:36)),3,4);reshape(uint64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3247: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3247"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3247"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_601
#AT_START_602
at_fn_group_banner 602 'mat73_write.at:3250' \
  "Write cell array with 2D 32-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "602. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3251" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3251"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3253: \$builddir/test_mat -v 7.3 -c int32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int32 write_cell_2d_numeric" "mat73_write.at:3253"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3253"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3300: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3300"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3300"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3301" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3301"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int32((1:12)),3,4);reshape(int32((13:24)),3,4);...
               reshape(int32((25:36)),3,4);reshape(int32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3324: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3324"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3324"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_602
#AT_START_603
at_fn_group_banner 603 'mat73_write.at:3327' \
  "Write cell array with 2D 32-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "603. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3328" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3328"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3330: \$builddir/test_mat -v 7.3 -c uint32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint32 write_cell_2d_numeric" "mat73_write.at:3330"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3330"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3377: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3377"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3377"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3378" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3378"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint32((1:12)),3,4);reshape(uint32((13:24)),3,4);...
               reshape(uint32((25:36)),3,4);reshape(uint32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3401: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3401"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3401"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_603
#AT_START_604
at_fn_group_banner 604 'mat73_write.at:3404' \
  "Write cell array with 2D 16-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "604. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3405" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3405"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3407: \$builddir/test_mat -v 7.3 -c int16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int16 write_cell_2d_numeric" "mat73_write.at:3407"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3407"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3454: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3454"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3454"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3455" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3455"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int16((1:12)),3,4);reshape(int16((13:24)),3,4);...
               reshape(int16((25:36)),3,4);reshape(int16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3478: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3478"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3478"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_604
#AT_START_605
at_fn_group_banner 605 'mat73_write.at:3481' \
  "Write cell array with 2D 16-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "605. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3482" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3482"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3484: \$builddir/test_mat -v 7.3 -c uint16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint16 write_cell_2d_numeric" "mat73_write.at:3484"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3484"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3531: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3531"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3531"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3532" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3532"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint16((1:12)),3,4);reshape(uint16((13:24)),3,4);...
               reshape(uint16((25:36)),3,4);reshape(uint16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3555: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3555"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3555"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_605
#AT_START_606
at_fn_group_banner 606 'mat73_write.at:3558' \
  "Write cell array with 2D 8-bit signed integer fields" "" 11
at_xfail=no
(
  $as_echo "606. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3559" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3559"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3561: \$builddir/test_mat -v 7.3 -c int8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int8 write_cell_2d_numeric" "mat73_write.at:3561"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3561"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3608: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3608"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3608"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3609" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3609"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int8((1:12)),3,4);reshape(int8((13:24)),3,4);...
               reshape(int8((25:36)),3,4);reshape(int8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3632: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3632"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3632"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_606
#AT_START_607
at_fn_group_banner 607 'mat73_write.at:3635' \
  "Write cell array with 2D 8-bit unsigned integer fields" "" 11
at_xfail=no
(
  $as_echo "607. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3636" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3636"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3638: \$builddir/test_mat -v 7.3 -c uint8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint8 write_cell_2d_numeric" "mat73_write.at:3638"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3638"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3685: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_write.at:3685"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3685"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3686" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3686"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint8((1:12)),3,4);reshape(uint8((13:24)),3,4);...
               reshape(uint8((25:36)),3,4);reshape(uint8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3709: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3709"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3709"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_607
#AT_START_608
at_fn_group_banner 608 'mat73_write.at:3712' \
  "Write cell array with 2D double-precision complex fields" "" 11
at_xfail=no
(
  $as_echo "608. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3713" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3713"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3715: \$builddir/test_mat -v 7.3 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 write_cell_complex_2d_numeric" "mat73_write.at:3715"
( $at_check_trace; $builddir/test_mat -v 7.3 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3715"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3762: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:3762"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3762"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3763" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3763"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape((1:12)+j*(51:62),3,4);...
               reshape((13:24)+j*(63:74),3,4);...
               reshape((25:36)+j*(75:86),3,4);...
               reshape((37:48)+j*(87:98),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3788: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3788"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3788"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_608
#AT_START_609
at_fn_group_banner 609 'mat73_write.at:3791' \
  "Write cell array with 2D single-precision complex fields" "" 11
at_xfail=no
(
  $as_echo "609. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3792" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3792"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3794: \$builddir/test_mat -v 7.3 -c single write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c single write_cell_complex_2d_numeric" "mat73_write.at:3794"
( $at_check_trace; $builddir/test_mat -v 7.3 -c single write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3794"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3841: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:3841"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3841"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3842" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3842"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(single((1:12)+j*(51:62)),3,4);...
               reshape(single((13:24)+j*(63:74)),3,4);...
               reshape(single((25:36)+j*(75:86)),3,4);...
               reshape(single((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3867: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3867"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3867"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_609
#AT_START_610
at_fn_group_banner 610 'mat73_write.at:3870' \
  "Write cell array with 2D 64-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "610. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3871" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3871"
$as_echo "mat73_write.at:3872" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3872"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3874: \$builddir/test_mat -v 7.3 -c int64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int64 write_cell_complex_2d_numeric" "mat73_write.at:3874"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3874"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3921: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:3921"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3921"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:3922" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3922"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int64((1:12)+j*(51:62)),3,4);...
               reshape(int64((13:24)+j*(63:74)),3,4);...
               reshape(int64((25:36)+j*(75:86)),3,4);...
               reshape(int64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:3947: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:3947"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3947"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_610
#AT_START_611
at_fn_group_banner 611 'mat73_write.at:3950' \
  "Write cell array with 2D 64-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "611. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:3951" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3951"
$as_echo "mat73_write.at:3952" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:3952"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:3954: \$builddir/test_mat -v 7.3 -c uint64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint64 write_cell_complex_2d_numeric" "mat73_write.at:3954"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:3954"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4001: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4001"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4001"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4002" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4002"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint64((1:12)+j*(51:62)),3,4);...
               reshape(uint64((13:24)+j*(63:74)),3,4);...
               reshape(uint64((25:36)+j*(75:86)),3,4);...
               reshape(uint64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4027: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4027"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4027"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_611
#AT_START_612
at_fn_group_banner 612 'mat73_write.at:4030' \
  "Write cell array with 2D 32-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "612. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:4031" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4031"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:4033: \$builddir/test_mat -v 7.3 -c int32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int32 write_cell_complex_2d_numeric" "mat73_write.at:4033"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4033"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4080: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4080"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4080"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4081" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4081"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int32((1:12)+j*(51:62)),3,4);...
               reshape(int32((13:24)+j*(63:74)),3,4);...
               reshape(int32((25:36)+j*(75:86)),3,4);...
               reshape(int32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4106: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4106"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4106"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_612
#AT_START_613
at_fn_group_banner 613 'mat73_write.at:4109' \
  "Write cell array with 2D 32-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "613. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:4110" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4110"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:4112: \$builddir/test_mat -v 7.3 -c uint32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint32 write_cell_complex_2d_numeric" "mat73_write.at:4112"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4112"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4159: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4159"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4159"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4160" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4160"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint32((1:12)+j*(51:62)),3,4);...
               reshape(uint32((13:24)+j*(63:74)),3,4);...
               reshape(uint32((25:36)+j*(75:86)),3,4);...
               reshape(uint32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4185: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4185"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4185"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_613
#AT_START_614
at_fn_group_banner 614 'mat73_write.at:4188' \
  "Write cell array with 2D 16-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "614. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:4189" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4189"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:4191: \$builddir/test_mat -v 7.3 -c int16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int16 write_cell_complex_2d_numeric" "mat73_write.at:4191"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4191"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4238: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4238"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4238"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4239" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4239"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int16((1:12)+j*(51:62)),3,4);...
               reshape(int16((13:24)+j*(63:74)),3,4);...
               reshape(int16((25:36)+j*(75:86)),3,4);...
               reshape(int16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4264: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4264"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4264"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_614
#AT_START_615
at_fn_group_banner 615 'mat73_write.at:4267' \
  "Write cell array with 2D 16-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "615. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:4268" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4268"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:4270: \$builddir/test_mat -v 7.3 -c uint16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint16 write_cell_complex_2d_numeric" "mat73_write.at:4270"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4270"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4317: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4317"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4317"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4318" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4318"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint16((1:12)+j*(51:62)),3,4);...
               reshape(uint16((13:24)+j*(63:74)),3,4);...
               reshape(uint16((25:36)+j*(75:86)),3,4);...
               reshape(uint16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4343: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4343"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4343"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_615
#AT_START_616
at_fn_group_banner 616 'mat73_write.at:4346' \
  "Write cell array with 2D 8-bit signed integer complex fields" "" 11
at_xfail=no
(
  $as_echo "616. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:4347" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4347"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:4349: \$builddir/test_mat -v 7.3 -c int8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c int8 write_cell_complex_2d_numeric" "mat73_write.at:4349"
( $at_check_trace; $builddir/test_mat -v 7.3 -c int8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4349"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4396: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4396"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4396"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4397" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4397"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int8((1:12)+j*(51:62)),3,4);...
               reshape(int8((13:24)+j*(63:74)),3,4);...
               reshape(int8((25:36)+j*(75:86)),3,4);...
               reshape(int8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4422: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4422"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_616
#AT_START_617
at_fn_group_banner 617 'mat73_write.at:4425' \
  "Write cell array with 2D 8-bit unsigned integer complex fields" "" 11
at_xfail=no
(
  $as_echo "617. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_write.at:4426" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4426"
{ set +x
$as_echo "$at_srcdir/mat73_write.at:4428: \$builddir/test_mat -v 7.3 -c uint8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -c uint8 write_cell_complex_2d_numeric" "mat73_write.at:4428"
( $at_check_trace; $builddir/test_mat -v 7.3 -c uint8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4428"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4475: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_write.at:4475"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4475"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_write.at:4476" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_write.at:4476"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint8((1:12)+j*(51:62)),3,4);...
               reshape(uint8((13:24)+j*(63:74)),3,4);...
               reshape(uint8((25:36)+j*(75:86)),3,4);...
               reshape(uint8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_write.at:4501: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_write.at:4501"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_write.at:4501"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_617
#AT_START_618
at_fn_group_banner 618 'mat73_compressed_write.at:27' \
  "Write 2D double-precision array" "                " 12
at_xfail=no
(
  $as_echo "618. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:28" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:28"
$as_echo "mat73_compressed_write.at:29" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:29"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:31: \$builddir/test_mat -v 7.3 -z -c double write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c double write_2d_numeric" "mat73_compressed_write.at:31"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c double write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:31"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:47: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:47"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:47"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:48" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:48"
cat >test_write_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:68: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:68"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:68"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_618
#AT_START_619
at_fn_group_banner 619 'mat73_compressed_write.at:71' \
  "Write 2D single-precision array" "                " 12
at_xfail=no
(
  $as_echo "619. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:72" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:72"
$as_echo "mat73_compressed_write.at:73" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:73"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:75: \$builddir/test_mat -v 7.3 -z -c single write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c single write_2d_numeric" "mat73_compressed_write.at:75"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c single write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:75"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:91: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:91"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:91"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:92" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:92"
cat >test_write_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = single(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:112: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:112"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:112"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_619
#AT_START_620
at_fn_group_banner 620 'mat73_compressed_write.at:115' \
  "Write 2D 64-bit integer array" "                  " 12
at_xfail=no
(
  $as_echo "620. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:116" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:116"
$as_echo "mat73_compressed_write.at:117" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:117"
$as_echo "mat73_compressed_write.at:118" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:118"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:120: \$builddir/test_mat -v 7.3 -z -c int64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int64 write_2d_numeric" "mat73_compressed_write.at:120"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:120"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:136: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:136"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:136"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:137" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:137"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:157: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:157"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:157"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_620
#AT_START_621
at_fn_group_banner 621 'mat73_compressed_write.at:160' \
  "Write 2D 64-bit unsigned integer array" "         " 12
at_xfail=no
(
  $as_echo "621. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:161" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:161"
$as_echo "mat73_compressed_write.at:162" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:162"
$as_echo "mat73_compressed_write.at:163" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:163"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:165: \$builddir/test_mat -v 7.3 -z -c uint64 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint64 write_2d_numeric" "mat73_compressed_write.at:165"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint64 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:165"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:181: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:181"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:181"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:182" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:182"
cat >test_write_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint64(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:202: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:202"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:202"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_621
#AT_START_622
at_fn_group_banner 622 'mat73_compressed_write.at:205' \
  "Write 2D 32-bit integer array" "                  " 12
at_xfail=no
(
  $as_echo "622. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:206" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:206"
$as_echo "mat73_compressed_write.at:207" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:207"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:209: \$builddir/test_mat -v 7.3 -z -c int32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int32 write_2d_numeric" "mat73_compressed_write.at:209"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:209"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:225: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:225"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:225"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:226" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:226"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:246: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:246"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:246"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_622
#AT_START_623
at_fn_group_banner 623 'mat73_compressed_write.at:249' \
  "Write 2D 32-bit unsigned integer array" "         " 12
at_xfail=no
(
  $as_echo "623. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:250" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:250"
$as_echo "mat73_compressed_write.at:251" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:251"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:253: \$builddir/test_mat -v 7.3 -z -c uint32 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint32 write_2d_numeric" "mat73_compressed_write.at:253"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint32 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:253"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:269: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:269"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:269"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:270" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:270"
cat >test_write_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint32(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:290: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:290"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:290"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_623
#AT_START_624
at_fn_group_banner 624 'mat73_compressed_write.at:293' \
  "Write 2D 16-bit integer array" "                  " 12
at_xfail=no
(
  $as_echo "624. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:294" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:294"
$as_echo "mat73_compressed_write.at:295" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:295"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:297: \$builddir/test_mat -v 7.3 -z -c int16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int16 write_2d_numeric" "mat73_compressed_write.at:297"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:297"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:313: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:313"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:313"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:314" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:314"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:334: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:334"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:334"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_624
#AT_START_625
at_fn_group_banner 625 'mat73_compressed_write.at:337' \
  "Write 2D 16-bit unsigned integer array" "         " 12
at_xfail=no
(
  $as_echo "625. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:338" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:338"
$as_echo "mat73_compressed_write.at:339" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:339"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:341: \$builddir/test_mat -v 7.3 -z -c uint16 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint16 write_2d_numeric" "mat73_compressed_write.at:341"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint16 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:341"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:357: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:357"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:357"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:358" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:358"
cat >test_write_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint16(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:378: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:378"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:378"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_625
#AT_START_626
at_fn_group_banner 626 'mat73_compressed_write.at:381' \
  "Write 2D 8-bit integer array" "                   " 12
at_xfail=no
(
  $as_echo "626. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:382" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:382"
$as_echo "mat73_compressed_write.at:383" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:383"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:385: \$builddir/test_mat -v 7.3 -z -c int8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int8 write_2d_numeric" "mat73_compressed_write.at:385"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:385"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:401: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:401"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:401"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:402" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:402"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = int8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:422: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:422"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_626
#AT_START_627
at_fn_group_banner 627 'mat73_compressed_write.at:425' \
  "Write 2D 8-bit unsigned integer array" "          " 12
at_xfail=no
(
  $as_echo "627. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:426" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:426"
$as_echo "mat73_compressed_write.at:427" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:427"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:429: \$builddir/test_mat -v 7.3 -z -c uint8 write_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint8 write_2d_numeric" "mat73_compressed_write.at:429"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint8 write_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:429"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 6 11 16 21 26 31 36 41 46 
2 7 12 17 22 27 32 37 42 47 
3 8 13 18 23 28 33 38 43 48 
4 9 14 19 24 29 34 39 44 49 
5 10 15 20 25 30 35 40 45 50 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:445: \$builddir/test_mat readvar test_write_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_2d_numeric.mat a" "mat73_compressed_write.at:445"
( $at_check_trace; $builddir/test_mat readvar test_write_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:445"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:446" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:446"
cat >test_write_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_2d_numeric.mat
    expdata = uint8(reshape(1:50,5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:466: \$MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:466"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:466"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_627
#AT_START_628
at_fn_group_banner 628 'mat73_compressed_write.at:469' \
  "Write 2D double-precision complex array" "        " 12
at_xfail=no
(
  $as_echo "628. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:470" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:470"
$as_echo "mat73_compressed_write.at:471" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:471"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:473: \$builddir/test_mat -v 7.3 -z -c double write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c double write_complex_2d_numeric" "mat73_compressed_write.at:473"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c double write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:473"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:489: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:489"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:489"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:490" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:490"
cat >test_write_complex_2d_numeric_double.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:510: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:510"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:510"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_628
#AT_START_629
at_fn_group_banner 629 'mat73_compressed_write.at:513' \
  "Write 2D single-precision complex array" "        " 12
at_xfail=no
(
  $as_echo "629. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:514" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:514"
$as_echo "mat73_compressed_write.at:515" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:515"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:517: \$builddir/test_mat -v 7.3 -z -c single write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c single write_complex_2d_numeric" "mat73_compressed_write.at:517"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c single write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:517"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:533: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:533"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:533"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:534" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:534"
cat >test_write_complex_2d_numeric_single.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = single(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:554: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:554"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_single;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:554"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_629
#AT_START_630
at_fn_group_banner 630 'mat73_compressed_write.at:557' \
  "Write 2D 64-bit integer complex array" "          " 12
at_xfail=no
(
  $as_echo "630. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:558" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:558"
$as_echo "mat73_compressed_write.at:559" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:559"
$as_echo "mat73_compressed_write.at:560" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:560"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:562: \$builddir/test_mat -v 7.3 -z -c int64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int64 write_complex_2d_numeric" "mat73_compressed_write.at:562"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:562"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:578: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:578"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:578"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:579" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:579"
cat >test_write_complex_2d_numeric_int64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:599: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:599"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:599"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_630
#AT_START_631
at_fn_group_banner 631 'mat73_compressed_write.at:602' \
  "Write 2D 64-bit unsigned integer complex array" " " 12
at_xfail=no
(
  $as_echo "631. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:603" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:603"
$as_echo "mat73_compressed_write.at:604" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:604"
$as_echo "mat73_compressed_write.at:605" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:605"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:607: \$builddir/test_mat -v 7.3 -z -c uint64 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint64 write_complex_2d_numeric" "mat73_compressed_write.at:607"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint64 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:607"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:623: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:623"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:623"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:624" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:624"
cat >test_write_complex_2d_numeric_uint64.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint64(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:644: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:644"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint64;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:644"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_631
#AT_START_632
at_fn_group_banner 632 'mat73_compressed_write.at:647' \
  "Write 2D 32-bit integer complex array" "          " 12
at_xfail=no
(
  $as_echo "632. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:648" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:648"
$as_echo "mat73_compressed_write.at:649" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:649"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:651: \$builddir/test_mat -v 7.3 -z -c int32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int32 write_complex_2d_numeric" "mat73_compressed_write.at:651"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:651"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:667: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:667"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:667"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:668" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:668"
cat >test_write_complex_2d_numeric_int32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:688: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:688"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:688"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_632
#AT_START_633
at_fn_group_banner 633 'mat73_compressed_write.at:691' \
  "Write 2D 32-bit unsigned integer complex array" " " 12
at_xfail=no
(
  $as_echo "633. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:692" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:692"
$as_echo "mat73_compressed_write.at:693" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:693"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:695: \$builddir/test_mat -v 7.3 -z -c uint32 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint32 write_complex_2d_numeric" "mat73_compressed_write.at:695"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint32 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:695"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:711: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:711"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:711"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:712" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:712"
cat >test_write_complex_2d_numeric_uint32.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint32(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:732: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:732"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint32;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:732"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_633
#AT_START_634
at_fn_group_banner 634 'mat73_compressed_write.at:735' \
  "Write 2D 16-bit integer complex array" "          " 12
at_xfail=no
(
  $as_echo "634. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:736" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:736"
$as_echo "mat73_compressed_write.at:737" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:737"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:739: \$builddir/test_mat -v 7.3 -z -c int16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int16 write_complex_2d_numeric" "mat73_compressed_write.at:739"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:739"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:755: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:755"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:755"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:756" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:756"
cat >test_write_complex_2d_numeric_int16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:776: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:776"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:776"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_634
#AT_START_635
at_fn_group_banner 635 'mat73_compressed_write.at:779' \
  "Write 2D 16-bit unsigned integer complex array" " " 12
at_xfail=no
(
  $as_echo "635. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:780" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:780"
$as_echo "mat73_compressed_write.at:781" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:781"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:783: \$builddir/test_mat -v 7.3 -z -c uint16 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint16 write_complex_2d_numeric" "mat73_compressed_write.at:783"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint16 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:783"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:799: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:799"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:799"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:800" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:800"
cat >test_write_complex_2d_numeric_uint16.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint16(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:820: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:820"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint16;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:820"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_635
#AT_START_636
at_fn_group_banner 636 'mat73_compressed_write.at:823' \
  "Write 2D 8-bit integer complex array" "           " 12
at_xfail=no
(
  $as_echo "636. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:824" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:824"
$as_echo "mat73_compressed_write.at:825" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:825"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:827: \$builddir/test_mat -v 7.3 -z -c int8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int8 write_complex_2d_numeric" "mat73_compressed_write.at:827"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:827"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:843: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:843"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:843"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:844" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:844"
cat >test_write_complex_2d_numeric_int8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = int8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:864: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:864"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_int8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:864"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_636
#AT_START_637
at_fn_group_banner 637 'mat73_compressed_write.at:867' \
  "Write 2D 8-bit unsigned integer complex array" "  " 12
at_xfail=no
(
  $as_echo "637. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:868" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:868"
$as_echo "mat73_compressed_write.at:869" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:869"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:871: \$builddir/test_mat -v 7.3 -z -c uint8 write_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint8 write_complex_2d_numeric" "mat73_compressed_write.at:871"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint8 write_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:871"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 5 x 10
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 6 + 56i 11 + 61i 16 + 66i 21 + 71i 26 + 76i 31 + 81i 36 + 86i 41 + 91i 46 + 96i 
2 + 52i 7 + 57i 12 + 62i 17 + 67i 22 + 72i 27 + 77i 32 + 82i 37 + 87i 42 + 92i 47 + 97i 
3 + 53i 8 + 58i 13 + 63i 18 + 68i 23 + 73i 28 + 78i 33 + 83i 38 + 88i 43 + 93i 48 + 98i 
4 + 54i 9 + 59i 14 + 64i 19 + 69i 24 + 74i 29 + 79i 34 + 84i 39 + 89i 44 + 94i 49 + 99i 
5 + 55i 10 + 60i 15 + 65i 20 + 70i 25 + 75i 30 + 80i 35 + 85i 40 + 90i 45 + 95i 50 + 100i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:887: \$builddir/test_mat readvar test_write_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_complex_2d_numeric.mat a" "mat73_compressed_write.at:887"
( $at_check_trace; $builddir/test_mat readvar test_write_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:887"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:888" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:888"
cat >test_write_complex_2d_numeric_uint8.m <<'_ATEOF'

try
    load test_write_complex_2d_numeric.mat
    expdata = uint8(reshape((1:50) + j*(51:100),5,10));
    pass = true;
    pass = pass && isa(a,class(expdata));
    pass = pass && all(size(a)==size(expdata));
    pass = pass && all(a(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:908: \$MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:908"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_complex_2d_numeric_uint8;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:908"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_637
#AT_START_638
at_fn_group_banner 638 'mat73_compressed_write.at:911' \
  "Write 2D sparse double-precision array" "         " 12
at_xfail=no
(
  $as_echo "638. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:912" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:912"
$as_echo "mat73_compressed_write.at:913" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:913"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:915: \$builddir/test_mat -v 7.3 -z -c double write_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c double write_sparse" "mat73_compressed_write.at:915"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c double write_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:915"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array
 Data Type: IEEE 754 double-precision
{
    (1,1)  1
    (5,1)  5
    (2,2)  7
    (3,2)  8
    (4,2)  9
    (1,3)  11
    (5,3)  15
    (2,4)  17
    (3,4)  18
    (4,4)  19
    (1,5)  21
    (5,5)  25
    (2,6)  27
    (3,6)  28
    (4,6)  29
    (1,7)  31
    (5,7)  35
    (2,8)  37
    (3,8)  38
    (4,8)  39
    (1,9)  41
    (5,9)  45
    (2,10)  47
    (3,10)  48
    (4,10)  49
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:951: \$builddir/test_mat readvar test_write_sparse.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse.mat sparse_matrix" "mat73_compressed_write.at:951"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:951"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:952" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:952"
cat >test_write_sparse_double.m <<'_ATEOF'

try
    load test_write_sparse.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape(1:50,5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:976: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:976"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:976"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_638
#AT_START_639
at_fn_group_banner 639 'mat73_compressed_write.at:979' \
  "Write 2D sparse complex double-precision array" " " 12
at_xfail=no
(
  $as_echo "639. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:980" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:980"
$as_echo "mat73_compressed_write.at:981" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:981"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:983: \$builddir/test_mat -v 7.3 -z -c double write_complex_sparse"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c double write_complex_sparse" "mat73_compressed_write.at:983"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c double write_complex_sparse
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:983"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: sparse_matrix
      Rank: 2
Dimensions: 5 x 10
Class Type: Sparse Array (complex)
 Data Type: IEEE 754 double-precision
{
    (1,1)  1 + 51i
    (5,1)  5 + 55i
    (2,2)  7 + 57i
    (3,2)  8 + 58i
    (4,2)  9 + 59i
    (1,3)  11 + 61i
    (5,3)  15 + 65i
    (2,4)  17 + 67i
    (3,4)  18 + 68i
    (4,4)  19 + 69i
    (1,5)  21 + 71i
    (5,5)  25 + 75i
    (2,6)  27 + 77i
    (3,6)  28 + 78i
    (4,6)  29 + 79i
    (1,7)  31 + 81i
    (5,7)  35 + 85i
    (2,8)  37 + 87i
    (3,8)  38 + 88i
    (4,8)  39 + 89i
    (1,9)  41 + 91i
    (5,9)  45 + 95i
    (2,10)  47 + 97i
    (3,10)  48 + 98i
    (4,10)  49 + 99i
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1019: \$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix" "mat73_compressed_write.at:1019"
( $at_check_trace; $builddir/test_mat readvar test_write_sparse_complex.mat sparse_matrix
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1019"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1020" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1020"
cat >test_write_sparse_complex_double.m <<'_ATEOF'

try
    load test_write_sparse_complex.mat
    expdata = zeros(5,10);
    expdata(1:4:end,1:2:end) = 1;
    expdata(2:4,2:2:end) = 1;
    expdata = expdata.*reshape((1:50) + j*(51:100),5,10);
    pass = true;
    pass = pass && isa(sparse_matrix,class(expdata));
    pass = pass && issparse(sparse_matrix);
    pass = pass && all(size(sparse_matrix)==size(expdata));
    pass = pass && all(sparse_matrix(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1044: \$MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1044"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_sparse_complex_double;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1044"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_639
#AT_START_640
at_fn_group_banner 640 'mat73_compressed_write.at:1047' \
  "Write 2D empty array" "                           " 12
at_xfail=no
(
  $as_echo "640. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1048" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1048"
$as_echo "mat73_compressed_write.at:1049" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1049"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1051: \$builddir/test_mat -v 7.3 -z -c double write_empty_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c double write_empty_2d_numeric" "mat73_compressed_write.at:1051"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c double write_empty_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1051"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: empty
      Rank: 2
Dimensions: 0 x 10
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1060: \$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_2d_numeric.mat empty" "mat73_compressed_write.at:1060"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_2d_numeric.mat empty
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1060"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1061" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1061"
cat >test_write_empty.m <<'_ATEOF'

try
    load test_write_empty_2d_numeric.mat
    expdata = zeros(0,10);
    pass = true;
    pass = pass && isa(empty,class(expdata));
    pass = pass && isempty(empty);
    pass = pass && all(size(empty)==size(expdata));
    pass = pass && all(empty(:)==expdata(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1082: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1082"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1082"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_640
#AT_START_641
at_fn_group_banner 641 'mat73_compressed_write.at:1085' \
  "Write character array" "                          " 12
at_xfail=no
(
  $as_echo "641. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1086" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1086"
$as_echo "mat73_compressed_write.at:1087" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1087"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1088: \$builddir/test_mat -v 7.3 -z write_char"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_char" "mat73_compressed_write.at:1088"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_char
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1088"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 26
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
{
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890!@#$%^&*()-_=+`~
[{]}\|;:'",<.>/?          
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1103: \$builddir/test_mat readvar test_write_char.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_char.mat a" "mat73_compressed_write.at:1103"
( $at_check_trace; $builddir/test_mat readvar test_write_char.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1103"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1104" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1104"
cat >test_write_char.m <<'_ATEOF'

try
    load test_write_char.mat
    expdata = ['abcdefghijklmnopqrstuvwxyz';
               'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
               '1234567890!@#$%^&*()-_=+`~';
               '[{]}\|;:''",<.>/?          '];
    pass = true;
    pass = pass && isequal(expdata,a);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1125: \$MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1125"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_char;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1125"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_641
#AT_START_642
at_fn_group_banner 642 'mat73_compressed_write.at:1128' \
  "Write empty structure array" "                    " 12
at_xfail=no
(
  $as_echo "642. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1129" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1129"
$as_echo "mat73_compressed_write.at:1130" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1130"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1132: \$builddir/test_mat -v 7.3 -z write_empty_struct"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_empty_struct" "mat73_compressed_write.at:1132"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_empty_struct
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1132"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1143: \$builddir/test_mat readvar test_write_empty_struct.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var1" "mat73_compressed_write.at:1143"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1143"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1158: \$builddir/test_mat readvar test_write_empty_struct.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var2" "mat73_compressed_write.at:1158"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1158"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var3
      Rank: 2
Dimensions: 1 x 1
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1179: \$builddir/test_mat readvar test_write_empty_struct.mat var3"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var3" "mat73_compressed_write.at:1179"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var3
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1179"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var4
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Character Array
 Data Type: 8-bit, unsigned integer
      Name: field1
      Rank: 2
Dimensions: 0 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: field2
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1214: \$builddir/test_mat readvar test_write_empty_struct.mat var4"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_struct.mat var4" "mat73_compressed_write.at:1214"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_struct.mat var4
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1214"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1215" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1215"
cat >test_write_empty_struct.m <<'_ATEOF'

try
    load test_write_empty_struct.mat
    expdata1 = repmat(struct,0,1);
    expdata2 = repmat(struct('field1',zeros(0,0),'field2',zeros(0,0)),0,1);
    expdata3 = struct('field1',zeros(0,1),'field2',zeros(0,1));
    expdata4(1).field1 = zeros(0,1);
    expdata4(1).field2 = repmat(' ',0,1);
    expdata4(2).field1 = repmat(struct,0,1);
    expdata4(2).field2 = repmat({zeros(0,0)},0,1);
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
    pass = pass && isequal(var3,expdata3);
    pass = pass && isequal(var4,expdata4(:));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1242: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1242"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_struct;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1242"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_642
#AT_START_643
at_fn_group_banner 643 'mat73_compressed_write.at:1245' \
  "Write structure array with 2D double-precision fields" "" 12
at_xfail=no
(
  $as_echo "643. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1246" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1246"
$as_echo "mat73_compressed_write.at:1247" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1247"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1249: \$builddir/test_mat -v 7.3 -z write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_struct_2d_numeric" "mat73_compressed_write.at:1249"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1249"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1300: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1300"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1300"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1301" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1301"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape((1:12),3,4);
    expdata(1).field2 = reshape((13:24),3,4);
    expdata(2).field1 = reshape((25:36),3,4);
    expdata(2).field2 = reshape((37:48),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1326: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1326"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1326"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_643
#AT_START_644
at_fn_group_banner 644 'mat73_compressed_write.at:1329' \
  "Write structure array with 2D single-precision fields" "" 12
at_xfail=no
(
  $as_echo "644. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1330" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1330"
$as_echo "mat73_compressed_write.at:1331" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1331"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1333: \$builddir/test_mat -v 7.3 -z -c single write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c single write_struct_2d_numeric" "mat73_compressed_write.at:1333"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c single write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1333"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1384: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1384"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1384"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1385" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1385"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12)),3,4);
    expdata(1).field2 = reshape(single((13:24)),3,4);
    expdata(2).field1 = reshape(single((25:36)),3,4);
    expdata(2).field2 = reshape(single((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1410: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1410"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1410"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_644
#AT_START_645
at_fn_group_banner 645 'mat73_compressed_write.at:1413' \
  "Write structure array with 2D 64-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "645. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1414" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1414"
$as_echo "mat73_compressed_write.at:1415" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1415"
$as_echo "mat73_compressed_write.at:1416" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1416"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1418: \$builddir/test_mat -v 7.3 -z -c int64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int64 write_struct_2d_numeric" "mat73_compressed_write.at:1418"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1418"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1469: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1469"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1469"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1470" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1470"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12)),3,4);
    expdata(1).field2 = reshape(int64((13:24)),3,4);
    expdata(2).field1 = reshape(int64((25:36)),3,4);
    expdata(2).field2 = reshape(int64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1495: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1495"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1495"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_645
#AT_START_646
at_fn_group_banner 646 'mat73_compressed_write.at:1498' \
  "Write structure array with 2D 64-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "646. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1499" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1499"
$as_echo "mat73_compressed_write.at:1500" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1500"
$as_echo "mat73_compressed_write.at:1501" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1501"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1503: \$builddir/test_mat -v 7.3 -z -c uint64 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint64 write_struct_2d_numeric" "mat73_compressed_write.at:1503"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint64 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1503"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1554: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1554"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1554"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1555" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1555"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12)),3,4);
    expdata(1).field2 = reshape(uint64((13:24)),3,4);
    expdata(2).field1 = reshape(uint64((25:36)),3,4);
    expdata(2).field2 = reshape(uint64((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1580: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1580"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1580"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_646
#AT_START_647
at_fn_group_banner 647 'mat73_compressed_write.at:1583' \
  "Write structure array with 2D 32-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "647. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1584" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1584"
$as_echo "mat73_compressed_write.at:1585" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1585"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1587: \$builddir/test_mat -v 7.3 -z -c int32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int32 write_struct_2d_numeric" "mat73_compressed_write.at:1587"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1587"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1638: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1638"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1638"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1639" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1639"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12)),3,4);
    expdata(1).field2 = reshape(int32((13:24)),3,4);
    expdata(2).field1 = reshape(int32((25:36)),3,4);
    expdata(2).field2 = reshape(int32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1664: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1664"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1664"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_647
#AT_START_648
at_fn_group_banner 648 'mat73_compressed_write.at:1667' \
  "Write structure array with 2D 32-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "648. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1668" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1668"
$as_echo "mat73_compressed_write.at:1669" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1669"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1671: \$builddir/test_mat -v 7.3 -z -c uint32 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint32 write_struct_2d_numeric" "mat73_compressed_write.at:1671"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint32 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1671"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1722: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1722"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1722"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1723" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1723"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12)),3,4);
    expdata(1).field2 = reshape(uint32((13:24)),3,4);
    expdata(2).field1 = reshape(uint32((25:36)),3,4);
    expdata(2).field2 = reshape(uint32((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1748: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1748"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1748"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_648
#AT_START_649
at_fn_group_banner 649 'mat73_compressed_write.at:1751' \
  "Write structure array with 2D 16-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "649. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1752" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1752"
$as_echo "mat73_compressed_write.at:1753" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1753"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1755: \$builddir/test_mat -v 7.3 -z -c int16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int16 write_struct_2d_numeric" "mat73_compressed_write.at:1755"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1755"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1806: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1806"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1806"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1807" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1807"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12)),3,4);
    expdata(1).field2 = reshape(int16((13:24)),3,4);
    expdata(2).field1 = reshape(int16((25:36)),3,4);
    expdata(2).field2 = reshape(int16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1832: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1832"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1832"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_649
#AT_START_650
at_fn_group_banner 650 'mat73_compressed_write.at:1835' \
  "Write structure array with 2D 16-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "650. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1836" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1836"
$as_echo "mat73_compressed_write.at:1837" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1837"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1839: \$builddir/test_mat -v 7.3 -z -c uint16 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint16 write_struct_2d_numeric" "mat73_compressed_write.at:1839"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint16 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1839"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1890: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1890"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1890"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1891" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1891"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12)),3,4);
    expdata(1).field2 = reshape(uint16((13:24)),3,4);
    expdata(2).field1 = reshape(uint16((25:36)),3,4);
    expdata(2).field2 = reshape(uint16((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1916: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:1916"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1916"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_650
#AT_START_651
at_fn_group_banner 651 'mat73_compressed_write.at:1919' \
  "Write structure array with 2D 8-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "651. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:1920" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1920"
$as_echo "mat73_compressed_write.at:1921" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1921"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1923: \$builddir/test_mat -v 7.3 -z -c int8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int8 write_struct_2d_numeric" "mat73_compressed_write.at:1923"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1923"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:1974: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:1974"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:1974"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:1975" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:1975"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12)),3,4);
    expdata(1).field2 = reshape(int8((13:24)),3,4);
    expdata(2).field1 = reshape(int8((25:36)),3,4);
    expdata(2).field2 = reshape(int8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2000: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2000"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2000"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_651
#AT_START_652
at_fn_group_banner 652 'mat73_compressed_write.at:2003' \
  "Write structure array with 2D 8-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "652. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2004" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2004"
$as_echo "mat73_compressed_write.at:2005" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2005"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2007: \$builddir/test_mat -v 7.3 -z -c uint8 write_struct_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint8 write_struct_2d_numeric" "mat73_compressed_write.at:2007"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint8 write_struct_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2007"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2058: \$builddir/test_mat readvar test_write_struct_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_2d_numeric.mat a" "mat73_compressed_write.at:2058"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2058"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2059" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2059"
cat >test_write_struct_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12)),3,4);
    expdata(1).field2 = reshape(uint8((13:24)),3,4);
    expdata(2).field1 = reshape(uint8((25:36)),3,4);
    expdata(2).field2 = reshape(uint8((37:48)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2084: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2084"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2084"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_652
#AT_START_653
at_fn_group_banner 653 'mat73_compressed_write.at:2087' \
  "Write structure array with 2D double-precision complex fields" "" 12
at_xfail=no
(
  $as_echo "653. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2088" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2088"
$as_echo "mat73_compressed_write.at:2089" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2089"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2091: \$builddir/test_mat -v 7.3 -z write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_struct_complex_2d_numeric" "mat73_compressed_write.at:2091"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2091"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2142: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2142"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2142"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2143" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2143"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape((1:12) + j*(51:62),3,4);
    expdata(1).field2 = reshape((13:24) + j*(63:74),3,4);
    expdata(2).field1 = reshape((25:36) + j*(75:86),3,4);
    expdata(2).field2 = reshape((37:48) + j*(87:98),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2168: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2168"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2168"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_653
#AT_START_654
at_fn_group_banner 654 'mat73_compressed_write.at:2171' \
  "Write structure array with 2D single-precision complex fields" "" 12
at_xfail=no
(
  $as_echo "654. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2172" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2172"
$as_echo "mat73_compressed_write.at:2173" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2173"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2175: \$builddir/test_mat -v 7.3 -z -c single write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c single write_struct_complex_2d_numeric" "mat73_compressed_write.at:2175"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c single write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2175"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2226: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2226"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2226"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2227" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2227"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(single((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(single((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(single((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(single((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2252: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2252"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2252"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_654
#AT_START_655
at_fn_group_banner 655 'mat73_compressed_write.at:2255' \
  "Write structure array with 2D 64-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "655. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2256" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2256"
$as_echo "mat73_compressed_write.at:2257" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2257"
$as_echo "mat73_compressed_write.at:2258" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2258"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2260: \$builddir/test_mat -v 7.3 -z -c int64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int64 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2260"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2260"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2311: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2311"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2311"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2312" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2312"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2337: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2337"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2337"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_655
#AT_START_656
at_fn_group_banner 656 'mat73_compressed_write.at:2340' \
  "Write structure array with 2D 64-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "656. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2341" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2341"
$as_echo "mat73_compressed_write.at:2342" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2342"
$as_echo "mat73_compressed_write.at:2343" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2343"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2345: \$builddir/test_mat -v 7.3 -z -c uint64 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint64 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2345"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint64 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2345"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2396: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2396"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2396"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2397" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2397"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint64((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint64((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint64((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint64((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2422: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2422"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2422"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_656
#AT_START_657
at_fn_group_banner 657 'mat73_compressed_write.at:2425' \
  "Write structure array with 2D 32-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "657. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2426" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2426"
$as_echo "mat73_compressed_write.at:2427" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2427"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2429: \$builddir/test_mat -v 7.3 -z -c int32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int32 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2429"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2429"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2480: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2480"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2480"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2481" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2481"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2506: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2506"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2506"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_657
#AT_START_658
at_fn_group_banner 658 'mat73_compressed_write.at:2509' \
  "Write structure array with 2D 32-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "658. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2510" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2510"
$as_echo "mat73_compressed_write.at:2511" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2511"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2513: \$builddir/test_mat -v 7.3 -z -c uint32 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint32 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2513"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint32 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2513"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2564: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2564"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2564"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2565" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2565"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint32((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint32((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint32((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint32((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2590: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2590"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2590"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_658
#AT_START_659
at_fn_group_banner 659 'mat73_compressed_write.at:2593' \
  "Write structure array with 2D 16-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "659. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2594" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2594"
$as_echo "mat73_compressed_write.at:2595" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2595"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2597: \$builddir/test_mat -v 7.3 -z -c int16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int16 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2597"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2597"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2648: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2648"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2648"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2649" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2649"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2674: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2674"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2674"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_659
#AT_START_660
at_fn_group_banner 660 'mat73_compressed_write.at:2677' \
  "Write structure array with 2D 16-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "660. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2678" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2678"
$as_echo "mat73_compressed_write.at:2679" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2679"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2681: \$builddir/test_mat -v 7.3 -z -c uint16 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint16 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2681"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint16 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2681"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2732: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2732"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2732"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2733" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2733"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint16((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint16((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint16((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint16((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2758: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2758"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2758"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_660
#AT_START_661
at_fn_group_banner 661 'mat73_compressed_write.at:2761' \
  "Write structure array with 2D 8-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "661. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2762" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2762"
$as_echo "mat73_compressed_write.at:2763" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2763"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2765: \$builddir/test_mat -v 7.3 -z -c int8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int8 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2765"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2765"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2816: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2816"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2816"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2817" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2817"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(int8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(int8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(int8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(int8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2842: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2842"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2842"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_661
#AT_START_662
at_fn_group_banner 662 'mat73_compressed_write.at:2845' \
  "Write structure array with 2D 8-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "662. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2846" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2846"
$as_echo "mat73_compressed_write.at:2847" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2847"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2849: \$builddir/test_mat -v 7.3 -z -c uint8 write_struct_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint8 write_struct_complex_2d_numeric" "mat73_compressed_write.at:2849"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint8 write_struct_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2849"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2900: \$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a" "mat73_compressed_write.at:2900"
( $at_check_trace; $builddir/test_mat readvar test_write_struct_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2900"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2901" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2901"
cat >test_write_struct_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_struct_complex_2d_numeric.mat
    expdata(1).field1 = reshape(uint8((1:12) + j*(51:62)),3,4);
    expdata(1).field2 = reshape(uint8((13:24) + j*(63:74)),3,4);
    expdata(2).field1 = reshape(uint8((25:36) + j*(75:86)),3,4);
    expdata(2).field2 = reshape(uint8((37:48) + j*(87:98)),3,4);
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a(1).field1),class(expdata(1).field1));
    pass = pass && strcmp(class(a(1).field2),class(expdata(1).field2));
    pass = pass && strcmp(class(a(2).field1),class(expdata(2).field1));
    pass = pass && strcmp(class(a(2).field2),class(expdata(2).field2));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2926: \$MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2926"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_struct_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2926"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_662
#AT_START_663
at_fn_group_banner 663 'mat73_compressed_write.at:2929' \
  "Write empty cell array" "                         " 12
at_xfail=no
(
  $as_echo "663. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2930" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2930"
$as_echo "mat73_compressed_write.at:2931" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2931"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2932: \$builddir/test_mat -v 7.3 -z write_empty_cell"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_empty_cell" "mat73_compressed_write.at:2932"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_empty_cell
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2932"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var1
      Rank: 2
Dimensions: 0 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2943: \$builddir/test_mat readvar test_write_empty_cell.mat var1"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var1" "mat73_compressed_write.at:2943"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var1
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2943"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: var2
      Rank: 2
Dimensions: 2 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
      Rank: 2
Dimensions: 0 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2962: \$builddir/test_mat readvar test_write_empty_cell.mat var2"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_empty_cell.mat var2" "mat73_compressed_write.at:2962"
( $at_check_trace; $builddir/test_mat readvar test_write_empty_cell.mat var2
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2962"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:2963" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2963"
cat >test_write_empty_cell.m <<'_ATEOF'

try
    load test_write_empty_cell.mat
    expdata1 = cell(0,1);
    expdata2 = {zeros(0,1);zeros(0,1)};
    pass = true;
    pass = pass && isequal(var1,expdata1);
    pass = pass && isequal(var2,expdata2);
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2983: \$MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:2983"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_empty_cell;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2983"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_663
#AT_START_664
at_fn_group_banner 664 'mat73_compressed_write.at:2986' \
  "Write cell array with 2D double-precision fields" "" 12
at_xfail=no
(
  $as_echo "664. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:2987" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2987"
$as_echo "mat73_compressed_write.at:2988" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:2988"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:2990: \$builddir/test_mat -v 7.3 -z write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_cell_2d_numeric" "mat73_compressed_write.at:2990"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:2990"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3037: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3037"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3037"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3038" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3038"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape((1:12),3,4);reshape((13:24),3,4);...
               reshape((25:36),3,4);reshape((37:48),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3061: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3061"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3061"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_664
#AT_START_665
at_fn_group_banner 665 'mat73_compressed_write.at:3064' \
  "Write cell array with 2D single-precision fields" "" 12
at_xfail=no
(
  $as_echo "665. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3065" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3065"
$as_echo "mat73_compressed_write.at:3066" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3066"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3068: \$builddir/test_mat -v 7.3 -z -c single write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c single write_cell_2d_numeric" "mat73_compressed_write.at:3068"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c single write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3068"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array
 Data Type: IEEE 754 single-precision
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3115: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3115"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3115"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3116" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3116"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(single((1:12)),3,4);reshape(single((13:24)),3,4);...
               reshape(single((25:36)),3,4);reshape(single((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3139: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3139"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3139"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_665
#AT_START_666
at_fn_group_banner 666 'mat73_compressed_write.at:3142' \
  "Write cell array with 2D 64-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "666. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3143" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3143"
$as_echo "mat73_compressed_write.at:3144" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3144"
$as_echo "mat73_compressed_write.at:3145" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3145"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3147: \$builddir/test_mat -v 7.3 -z -c int64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int64 write_cell_2d_numeric" "mat73_compressed_write.at:3147"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3147"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array
 Data Type: 64-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3194: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3194"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3194"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3195" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3195"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int64((1:12)),3,4);reshape(int64((13:24)),3,4);...
               reshape(int64((25:36)),3,4);reshape(int64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3218: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3218"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3218"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_666
#AT_START_667
at_fn_group_banner 667 'mat73_compressed_write.at:3221' \
  "Write cell array with 2D 64-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "667. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3222" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3222"
$as_echo "mat73_compressed_write.at:3223" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3223"
$as_echo "mat73_compressed_write.at:3224" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3224"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3226: \$builddir/test_mat -v 7.3 -z -c uint64 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint64 write_cell_2d_numeric" "mat73_compressed_write.at:3226"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint64 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3226"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array
 Data Type: 64-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3273: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3273"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3273"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3274" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3274"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint64((1:12)),3,4);reshape(uint64((13:24)),3,4);...
               reshape(uint64((25:36)),3,4);reshape(uint64((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3297: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3297"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3297"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_667
#AT_START_668
at_fn_group_banner 668 'mat73_compressed_write.at:3300' \
  "Write cell array with 2D 32-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "668. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3301" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3301"
$as_echo "mat73_compressed_write.at:3302" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3302"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3304: \$builddir/test_mat -v 7.3 -z -c int32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int32 write_cell_2d_numeric" "mat73_compressed_write.at:3304"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3304"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array
 Data Type: 32-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3351: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3351"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3351"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3352" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3352"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int32((1:12)),3,4);reshape(int32((13:24)),3,4);...
               reshape(int32((25:36)),3,4);reshape(int32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3375: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3375"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3375"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_668
#AT_START_669
at_fn_group_banner 669 'mat73_compressed_write.at:3378' \
  "Write cell array with 2D 32-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "669. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3379" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3379"
$as_echo "mat73_compressed_write.at:3380" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3380"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3382: \$builddir/test_mat -v 7.3 -z -c uint32 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint32 write_cell_2d_numeric" "mat73_compressed_write.at:3382"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint32 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3382"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array
 Data Type: 32-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3429: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3429"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3429"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3430" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3430"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint32((1:12)),3,4);reshape(uint32((13:24)),3,4);...
               reshape(uint32((25:36)),3,4);reshape(uint32((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3453: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3453"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3453"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_669
#AT_START_670
at_fn_group_banner 670 'mat73_compressed_write.at:3456' \
  "Write cell array with 2D 16-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "670. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3457" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3457"
$as_echo "mat73_compressed_write.at:3458" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3458"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3460: \$builddir/test_mat -v 7.3 -z -c int16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int16 write_cell_2d_numeric" "mat73_compressed_write.at:3460"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3460"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array
 Data Type: 16-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3507: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3507"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3507"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3508" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3508"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int16((1:12)),3,4);reshape(int16((13:24)),3,4);...
               reshape(int16((25:36)),3,4);reshape(int16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3531: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3531"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3531"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_670
#AT_START_671
at_fn_group_banner 671 'mat73_compressed_write.at:3534' \
  "Write cell array with 2D 16-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "671. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3535" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3535"
$as_echo "mat73_compressed_write.at:3536" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3536"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3538: \$builddir/test_mat -v 7.3 -z -c uint16 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint16 write_cell_2d_numeric" "mat73_compressed_write.at:3538"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint16 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3538"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array
 Data Type: 16-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3585: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3585"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3585"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3586" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3586"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint16((1:12)),3,4);reshape(uint16((13:24)),3,4);...
               reshape(uint16((25:36)),3,4);reshape(uint16((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3609: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3609"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3609"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_671
#AT_START_672
at_fn_group_banner 672 'mat73_compressed_write.at:3612' \
  "Write cell array with 2D 8-bit signed integer fields" "" 12
at_xfail=no
(
  $as_echo "672. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3613" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3613"
$as_echo "mat73_compressed_write.at:3614" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3614"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3616: \$builddir/test_mat -v 7.3 -z -c int8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int8 write_cell_2d_numeric" "mat73_compressed_write.at:3616"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3616"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array
 Data Type: 8-bit, signed integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3663: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3663"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3663"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3664" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3664"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(int8((1:12)),3,4);reshape(int8((13:24)),3,4);...
               reshape(int8((25:36)),3,4);reshape(int8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3687: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3687"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3687"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_672
#AT_START_673
at_fn_group_banner 673 'mat73_compressed_write.at:3690' \
  "Write cell array with 2D 8-bit unsigned integer fields" "" 12
at_xfail=no
(
  $as_echo "673. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3691" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3691"
$as_echo "mat73_compressed_write.at:3692" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3692"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3694: \$builddir/test_mat -v 7.3 -z -c uint8 write_cell_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint8 write_cell_2d_numeric" "mat73_compressed_write.at:3694"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint8 write_cell_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3694"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
1 4 7 10 
2 5 8 11 
3 6 9 12 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
13 16 19 22 
14 17 20 23 
15 18 21 24 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
25 28 31 34 
26 29 32 35 
27 30 33 36 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array
 Data Type: 8-bit, unsigned integer
{
37 40 43 46 
38 41 44 47 
39 42 45 48 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3741: \$builddir/test_mat readvar test_write_cell_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_2d_numeric.mat a" "mat73_compressed_write.at:3741"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3741"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3742" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3742"
cat >test_write_cell_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_2d_numeric.mat
    expdata = {reshape(uint8((1:12)),3,4);reshape(uint8((13:24)),3,4);...
               reshape(uint8((25:36)),3,4);reshape(uint8((37:48)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3765: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3765"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3765"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_673
#AT_START_674
at_fn_group_banner 674 'mat73_compressed_write.at:3768' \
  "Write cell array with 2D double-precision complex fields" "" 12
at_xfail=no
(
  $as_echo "674. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3769" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3769"
$as_echo "mat73_compressed_write.at:3770" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3770"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3772: \$builddir/test_mat -v 7.3 -z write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z write_cell_complex_2d_numeric" "mat73_compressed_write.at:3772"
( $at_check_trace; $builddir/test_mat -v 7.3 -z write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3772"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3819: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:3819"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3819"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3820" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3820"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape((1:12)+j*(51:62),3,4);...
               reshape((13:24)+j*(63:74),3,4);...
               reshape((25:36)+j*(75:86),3,4);...
               reshape((37:48)+j*(87:98),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3845: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3845"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3845"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_674
#AT_START_675
at_fn_group_banner 675 'mat73_compressed_write.at:3848' \
  "Write cell array with 2D single-precision complex fields" "" 12
at_xfail=no
(
  $as_echo "675. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3849" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3849"
$as_echo "mat73_compressed_write.at:3850" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3850"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3852: \$builddir/test_mat -v 7.3 -z -c single write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c single write_cell_complex_2d_numeric" "mat73_compressed_write.at:3852"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c single write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3852"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: Single Precision Array (complex)
 Data Type: IEEE 754 single-precision
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3899: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:3899"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3899"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3900" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3900"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(single((1:12)+j*(51:62)),3,4);...
               reshape(single((13:24)+j*(63:74)),3,4);...
               reshape(single((25:36)+j*(75:86)),3,4);...
               reshape(single((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3925: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:3925"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3925"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_675
#AT_START_676
at_fn_group_banner 676 'mat73_compressed_write.at:3928' \
  "Write cell array with 2D 64-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "676. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:3929" >"$at_check_line_file"
(test $HAVE_INT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3929"
$as_echo "mat73_compressed_write.at:3930" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3930"
$as_echo "mat73_compressed_write.at:3931" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3931"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3933: \$builddir/test_mat -v 7.3 -z -c int64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int64 write_cell_complex_2d_numeric" "mat73_compressed_write.at:3933"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3933"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, signed integer array (complex)
 Data Type: 64-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:3980: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:3980"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:3980"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:3981" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:3981"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int64((1:12)+j*(51:62)),3,4);...
               reshape(int64((13:24)+j*(63:74)),3,4);...
               reshape(int64((25:36)+j*(75:86)),3,4);...
               reshape(int64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4006: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4006"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4006"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_676
#AT_START_677
at_fn_group_banner 677 'mat73_compressed_write.at:4009' \
  "Write cell array with 2D 64-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "677. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4010" >"$at_check_line_file"
(test $HAVE_UINT64 -eq 0) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4010"
$as_echo "mat73_compressed_write.at:4011" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4011"
$as_echo "mat73_compressed_write.at:4012" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4012"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4014: \$builddir/test_mat -v 7.3 -z -c uint64 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint64 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4014"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint64 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4014"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 64-bit, unsigned integer array (complex)
 Data Type: 64-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4061: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4061"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4061"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4062" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4062"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint64((1:12)+j*(51:62)),3,4);...
               reshape(uint64((13:24)+j*(63:74)),3,4);...
               reshape(uint64((25:36)+j*(75:86)),3,4);...
               reshape(uint64((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4087: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4087"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4087"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_677
#AT_START_678
at_fn_group_banner 678 'mat73_compressed_write.at:4090' \
  "Write cell array with 2D 32-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "678. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4091" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4091"
$as_echo "mat73_compressed_write.at:4092" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4092"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4094: \$builddir/test_mat -v 7.3 -z -c int32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int32 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4094"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4094"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, signed integer array (complex)
 Data Type: 32-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4141: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4141"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4141"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4142" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4142"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int32((1:12)+j*(51:62)),3,4);...
               reshape(int32((13:24)+j*(63:74)),3,4);...
               reshape(int32((25:36)+j*(75:86)),3,4);...
               reshape(int32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4167: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4167"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4167"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_678
#AT_START_679
at_fn_group_banner 679 'mat73_compressed_write.at:4170' \
  "Write cell array with 2D 32-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "679. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4171" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4171"
$as_echo "mat73_compressed_write.at:4172" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4172"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4174: \$builddir/test_mat -v 7.3 -z -c uint32 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint32 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4174"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint32 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4174"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 32-bit, unsigned integer array (complex)
 Data Type: 32-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4221: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4221"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4221"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4222" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4222"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint32((1:12)+j*(51:62)),3,4);...
               reshape(uint32((13:24)+j*(63:74)),3,4);...
               reshape(uint32((25:36)+j*(75:86)),3,4);...
               reshape(uint32((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4247: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4247"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4247"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_679
#AT_START_680
at_fn_group_banner 680 'mat73_compressed_write.at:4250' \
  "Write cell array with 2D 16-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "680. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4251" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4251"
$as_echo "mat73_compressed_write.at:4252" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4252"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4254: \$builddir/test_mat -v 7.3 -z -c int16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int16 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4254"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4254"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, signed integer array (complex)
 Data Type: 16-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4301: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4301"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4301"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4302" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4302"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int16((1:12)+j*(51:62)),3,4);...
               reshape(int16((13:24)+j*(63:74)),3,4);...
               reshape(int16((25:36)+j*(75:86)),3,4);...
               reshape(int16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4327: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4327"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4327"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_680
#AT_START_681
at_fn_group_banner 681 'mat73_compressed_write.at:4330' \
  "Write cell array with 2D 16-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "681. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4331" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4331"
$as_echo "mat73_compressed_write.at:4332" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4332"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4334: \$builddir/test_mat -v 7.3 -z -c uint16 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint16 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4334"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint16 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4334"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 16-bit, unsigned integer array (complex)
 Data Type: 16-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4381: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4381"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4381"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4382" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4382"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint16((1:12)+j*(51:62)),3,4);...
               reshape(uint16((13:24)+j*(63:74)),3,4);...
               reshape(uint16((25:36)+j*(75:86)),3,4);...
               reshape(uint16((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4407: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4407"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4407"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_681
#AT_START_682
at_fn_group_banner 682 'mat73_compressed_write.at:4410' \
  "Write cell array with 2D 8-bit signed integer complex fields" "" 12
at_xfail=no
(
  $as_echo "682. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4411" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4411"
$as_echo "mat73_compressed_write.at:4412" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4412"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4414: \$builddir/test_mat -v 7.3 -z -c int8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c int8 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4414"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c int8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4414"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, signed integer array (complex)
 Data Type: 8-bit, signed integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4461: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4461"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4461"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4462" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4462"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(int8((1:12)+j*(51:62)),3,4);...
               reshape(int8((13:24)+j*(63:74)),3,4);...
               reshape(int8((25:36)+j*(75:86)),3,4);...
               reshape(int8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4487: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4487"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4487"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_682
#AT_START_683
at_fn_group_banner 683 'mat73_compressed_write.at:4490' \
  "Write cell array with 2D 8-bit unsigned integer complex fields" "" 12
at_xfail=no
(
  $as_echo "683. $at_setup_line: testing $at_desc ..."
  $at_traceon

$as_echo "mat73_compressed_write.at:4491" >"$at_check_line_file"
(test $MAT73 -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4491"
$as_echo "mat73_compressed_write.at:4492" >"$at_check_line_file"
(test $COMPRESSION_ZLIB -ne 1) \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4492"
{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4494: \$builddir/test_mat -v 7.3 -z -c uint8 write_cell_complex_2d_numeric"
at_fn_check_prepare_dynamic "$builddir/test_mat -v 7.3 -z -c uint8 write_cell_complex_2d_numeric" "mat73_compressed_write.at:4494"
( $at_check_trace; $builddir/test_mat -v 7.3 -z -c uint8 write_cell_complex_2d_numeric
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo stdout:; cat "$at_stdout"
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4494"
$at_failed && at_fn_log_failure
$at_traceon; }

cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
1 + 51i 4 + 54i 7 + 57i 10 + 60i 
2 + 52i 5 + 55i 8 + 58i 11 + 61i 
3 + 53i 6 + 56i 9 + 59i 12 + 62i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
13 + 63i 16 + 66i 19 + 69i 22 + 72i 
14 + 64i 17 + 67i 20 + 70i 23 + 73i 
15 + 65i 18 + 68i 21 + 71i 24 + 74i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
25 + 75i 28 + 78i 31 + 81i 34 + 84i 
26 + 76i 29 + 79i 32 + 82i 35 + 85i 
27 + 77i 30 + 80i 33 + 83i 36 + 86i 
}
      Rank: 2
Dimensions: 3 x 4
Class Type: 8-bit, unsigned integer array (complex)
 Data Type: 8-bit, unsigned integer
{
37 + 87i 40 + 90i 43 + 93i 46 + 96i 
38 + 88i 41 + 91i 44 + 94i 47 + 97i 
39 + 89i 42 + 92i 45 + 95i 48 + 98i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4541: \$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a"
at_fn_check_prepare_dynamic "$builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a" "mat73_compressed_write.at:4541"
( $at_check_trace; $builddir/test_mat readvar test_write_cell_complex_2d_numeric.mat a
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4541"
$at_failed && at_fn_log_failure
$at_traceon; }

$as_echo "mat73_compressed_write.at:4542" >"$at_check_line_file"
(test -z "$MATLABEXE") \
  && at_fn_check_skip 77 "$at_srcdir/mat73_compressed_write.at:4542"
cat >test_write_cell_complex_2d_numeric.m <<'_ATEOF'

try
    load test_write_cell_complex_2d_numeric.mat
    expdata = {reshape(uint8((1:12)+j*(51:62)),3,4);...
               reshape(uint8((13:24)+j*(63:74)),3,4);...
               reshape(uint8((25:36)+j*(75:86)),3,4);...
               reshape(uint8((37:48)+j*(87:98)),3,4);}
    pass = true;
    pass = pass && isequal(a,expdata(:));
    pass = pass && strcmp(class(a{1}),class(expdata{1}));
    pass = pass && strcmp(class(a{2}),class(expdata{2}));
    pass = pass && strcmp(class(a{3}),class(expdata{3}));
    pass = pass && strcmp(class(a{4}),class(expdata{4}));
catch me
    pass = false;
end
if pass
    fprintf('PASSED\n');
else
    fprintf('FAILED\n');
end
_ATEOF

{ set +x
$as_echo "$at_srcdir/mat73_compressed_write.at:4567: \$MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | \$GREP PASSED"
at_fn_check_prepare_notrace 'a shell pipeline' "mat73_compressed_write.at:4567"
( $at_check_trace; $MATLABEXE -nosplash -nojvm -r 'test_write_cell_complex_2d_numeric;exit' | $GREP PASSED
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
echo >>"$at_stdout"; $as_echo "PASSED
" | \
  $at_diff - "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/mat73_compressed_write.at:4567"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_683
#AT_START_684
at_fn_group_banner 684 'struct_api.at:27' \
  "Create structure array" "                         " 13
at_xfail=no
(
  $as_echo "684. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
      Name: b
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[0] {
}
      Name: c
      Rank: 2
Dimensions: 0 x 0
Class Type: Structure
 Data Type: Structure
Fields[2] {
      Name: field1
      Rank: 0
      Name: field2
      Rank: 0
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/struct_api.at:64: \$builddir/test_mat struct_api_create"
at_fn_check_prepare_dynamic "$builddir/test_mat struct_api_create" "struct_api.at:64"
( $at_check_trace; $builddir/test_mat struct_api_create
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/struct_api.at:64"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_684
#AT_START_685
at_fn_group_banner 685 'struct_api.at:67' \
  "Set structure field" "                            " 13
at_xfail=no
(
  $as_echo "685. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 2 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
3 
4 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
}
      Name: field2
      Rank: 2
Dimensions: 1 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
8 9 
}
}
      Name: b
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 1 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
8 9 
}
      Name: field2
      Rank: 2
Dimensions: 1 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
}
      Name: field1
      Rank: 2
Dimensions: 3 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
3 
4 
}
      Name: field2
      Rank: 2
Dimensions: 2 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
1 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/struct_api.at:155: \$builddir/test_mat struct_api_setfield"
at_fn_check_prepare_dynamic "$builddir/test_mat struct_api_setfield" "struct_api.at:155"
( $at_check_trace; $builddir/test_mat struct_api_setfield
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/struct_api.at:155"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_685
#AT_START_686
at_fn_group_banner 686 'struct_api.at:158' \
  "Get structure fieldnames" "                       " 13
at_xfail=no
(
  $as_echo "686. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
Fieldnames of "a":
    0. field1
    1. field2
    2. field3
    3. field4
Fieldnames of "b":
  None
Fieldnames of "NULL":
  None
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/struct_api.at:171: \$builddir/test_mat struct_api_getfieldnames"
at_fn_check_prepare_dynamic "$builddir/test_mat struct_api_getfieldnames" "struct_api.at:171"
( $at_check_trace; $builddir/test_mat struct_api_getfieldnames
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/struct_api.at:171"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_686
#AT_START_687
at_fn_group_banner 687 'struct_api.at:174' \
  "Add fields to structure array" "                  " 13
at_xfail=no
(
  $as_echo "687. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 1
Class Type: Structure
 Data Type: Structure
Fields[4] {
      Name: field1
      Rank: 2
Dimensions: 2 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
1 
}
      Name: field2
      Rank: 2
Dimensions: 3 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
3 
4 
}
      Name: field1
      Rank: 2
Dimensions: 1 x 3
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 6 7 
}
      Name: field2
      Rank: 2
Dimensions: 1 x 2
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
8 9 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/struct_api.at:220: \$builddir/test_mat struct_api_addfield"
at_fn_check_prepare_dynamic "$builddir/test_mat struct_api_addfield" "struct_api.at:220"
( $at_check_trace; $builddir/test_mat struct_api_addfield
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/struct_api.at:220"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_687
#AT_START_688
at_fn_group_banner 688 'struct_api.at:223' \
  "Linearly index a structure" "                     " 13
at_xfail=no
(
  $as_echo "688. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 4 x 1
Class Type: Structure
 Data Type: Structure
Fields[12] {
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 13i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
4 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
16 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
4 + 16i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
7 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
19 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
7 + 19i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
10 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
22 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
10 + 22i 
}
}
      Name: a
      Rank: 2
Dimensions: 3 x 1
Class Type: Structure
 Data Type: Structure
Fields[9] {
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
12 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
0 + 12i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
13 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 13i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
14 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 14i 
}
}
      Name: a
      Rank: 2
Dimensions: 3 x 1
Class Type: Structure
 Data Type: Structure
Fields[9] {
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
12 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
0 + 12i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
4 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
16 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
4 + 16i 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
8 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
20 
}
      Name: z
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
8 + 20i 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/struct_api.at:488: \$builddir/test_mat struct_api_getlinear"
at_fn_check_prepare_dynamic "$builddir/test_mat struct_api_getlinear" "struct_api.at:488"
( $at_check_trace; $builddir/test_mat struct_api_getlinear
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/struct_api.at:488"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_688
#AT_START_689
at_fn_group_banner 689 'struct_api.at:491' \
  "Index structure via dimension slices" "           " 13
at_xfail=no
(
  $as_echo "689. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Name: a
      Rank: 4
Dimensions: 1 x 2 x 3 x 2
Class Type: Structure
 Data Type: Structure
Fields[24] {
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
65 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-65 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
68 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-68 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
89 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-89 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
92 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-92 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
113 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-113 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
116 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-116 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
305 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-305 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
308 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-308 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
329 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-329 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
332 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-332 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
353 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-353 
}
      Name: r
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
356 
}
      Name: c
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
-356 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/struct_api.at:694: \$builddir/test_mat struct_api_get"
at_fn_check_prepare_dynamic "$builddir/test_mat struct_api_get" "struct_api.at:694"
( $at_check_trace; $builddir/test_mat struct_api_get
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/struct_api.at:694"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_689
#AT_START_690
at_fn_group_banner 690 'cell_api.at:27' \
  "Set cell array elements" "                        " 13
at_xfail=no
(
  $as_echo "690. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Name: a
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
3 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
4 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 
}
}
      Name: a
      Rank: 2
Dimensions: 2 x 3
Class Type: Cell Array
 Data Type: Cell Array
{
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
7 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
8 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
3 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
9 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 
}
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/cell_api.at:129: \$builddir/test_mat cell_api_set"
at_fn_check_prepare_dynamic "$builddir/test_mat cell_api_set" "cell_api.at:129"
( $at_check_trace; $builddir/test_mat cell_api_set
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/cell_api.at:129"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_690
#AT_START_691
at_fn_group_banner 691 'cell_api.at:132' \
  "Linearly index cell array" "                      " 13
at_xfail=no
(
  $as_echo "691. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
0 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
3 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
4 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
6 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
7 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
0 + 4i 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 5i 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 6i 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
3 + 7i 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
1 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
5 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
1 + 5i 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
2 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
6 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array (complex)
 Data Type: IEEE 754 double-precision
{
2 + 6i 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/cell_api.at:262: \$builddir/test_mat  cell_api_getlinear"
at_fn_check_prepare_dynamic "$builddir/test_mat  cell_api_getlinear" "cell_api.at:262"
( $at_check_trace; $builddir/test_mat  cell_api_getlinear
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/cell_api.at:262"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_691
#AT_START_692
at_fn_group_banner 692 'cell_api.at:265' \
  "Index cell array via dimension slices" "          " 13
at_xfail=no
(
  $as_echo "692. $at_setup_line: testing $at_desc ..."
  $at_traceon


cat >expout <<'_ATEOF'
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
65 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
68 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
89 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
92 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
113 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
116 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
305 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
308 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
329 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
332 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
353 
}
      Rank: 2
Dimensions: 1 x 1
Class Type: Double Precision Array
 Data Type: IEEE 754 double-precision
{
356 
}
_ATEOF

windows_eol=no
case $host_os in
  mingw*)
    windows_eol=yes
    ;;
  *)
    if test "x$with_msvc_ld" = "xyes"; then
      windows_eol=yes
    fi
    ;;
esac
if test "$windows_eol" = "yes"; then
  while read -r l; do printf "%s\r\n" "$l"; done < expout > expout.t
  mv -f expout.t expout
fi

{ set +x
$as_echo "$at_srcdir/cell_api.at:353: \$builddir/test_mat  cell_api_getcells"
at_fn_check_prepare_dynamic "$builddir/test_mat  cell_api_getcells" "cell_api.at:353"
( $at_check_trace; $builddir/test_mat  cell_api_getcells
) >>"$at_stdout" 2>>"$at_stderr"
at_status=$? at_failed=false
$at_check_filter
echo stderr:; cat "$at_stderr"
$at_diff expout "$at_stdout" || at_failed=:
at_fn_check_status 0 $at_status "$at_srcdir/cell_api.at:353"
$at_failed && at_fn_log_failure
$at_traceon; }

  set +x
  $at_times_p && times >"$at_times_file"
) 5>&1 2>&1 7>&- | eval $at_tee_pipe
read at_status <"$at_status_file"
#AT_STOP_692
