path: root/tools/testh5toh4

#!/bin/sh

h5toh4=./h5toh4		# a relative name
cmp='cmp -s'
diff='diff -c'

RM='rm -f'
SED='sed '
H4DUMP='hdp'

# The build (current) directory might be different than the source directory.
if test "X$srcdir" = X; then
    srcdir=.
fi
mkdir testfiles >/dev/null 2>&1

INDIR="$srcdir/testfiles"
OUTDIR="./testfiles"

nerrors=0
verbose=yes

# Print a line-line message left justified in a field of 70 characters
# beginning with the word "Testing".
TESTING()
{
    SPACES="                                                               "
    echo "Testing $* $SPACES" |cut -c1-70 |tr -d '\n'
}

# Run a test and print PASS or *FAIL*.  If a test fails then increment
# the `nerrors' global variable and (if $verbose is set) display the
# difference between the actual output and the expected output. The
# expected output is given by adding a `.dmp' extension to the root of
# the first argument to this function and the actual output file is
# calculated by replacing the `.dmp' with `.tmp'.  The actual output
# is not removed if $HDF5_NOCLEANUP has a value.
CONVERT()
{
    # Run h5toh4 convert.
    TESTING $h5toh4 $@

#
# Set up arguments to run the conversion test.
# The converter assumes all hdf5 files has the .h5 suffix as in the form
# of foo.h5.  It creates the corresponding hdf4 files with the .hdf suffix
# as in the form of foo.hdf.  One exception is that if exactly two file names
# are given, it treats the first argument as an hdf5 file and creates the
# corresponding hdf4 file with the name as the second argument, WITOUT
# any consideration of the suffix.
#
# If INDIR != OUTDIR, need to copy the input hdf5 files from the INDIR
# to the OUTDIR and transform the input file pathname because of the suffix
# convention mentioned above.  This way, the hdf4 files are always created
# in the OUTDIR directory.

# Need to run the following in a separate shell to preserve the
# positional parameters of THIS shell.  The current shell parameters
# are needed for the verification.  (In the next revision, will use
# the $OUTFILES values to do the verification.)
#

(
    INFILES=""
    OUTFILES=""

    case "$1" in
    "-m")	# multiple files conversion
	shift
	while [ $# -gt 0 ]
	do
	    if [ "$INDIR" != "$OUTDIR" ]
	    then
		cp $INDIR/$1 $OUTDIR/$1
	    fi
	    INFILES="$INFILES $OUTDIR/$1"
	    OUTFILES="$OUTFILES $OUTDIR/`basename $1 .h5`.hdf"
	    shift
	done
	set - "-m" $INFILES
	;;

    * ) # one file conversion
	case $# in
	1)  
	    if [ "$INDIR" != "$OUTDIR" ]
	    then
		cp $INDIR/$1 $OUTDIR/$1
	    fi
	    INFILES="$OUTDIR/$1"
	    OUTFILES="$OUTDIR/`basename $1 .h5`.hdf"
	    set - $INFILES
	    ;;
	    
	2)  # hdf4 file specified
	    if [ "$INDIR" != "$OUTDIR" ]
	    then
		cp $INDIR/$1 $OUTDIR/$1
	    fi
	    INFILES="$OUTDIR/$1"
	    OUTFILES="$2"
	    set - $OUTDIR/$1 $OUTDIR/$2
	    ;;

	*)  # Illegal
	    echo "Illegal arguments"
	    exit 1
	    ;;
	esac
	;;
    esac

    # run the conversion and remove input files that have been copied over
    $h5toh4 "$@" 2>/dev/null
    if [ "$INDIR" != "$OUTDIR" ]
    then
	$RM $INFILES
    fi

)

    # verify results
    case "$1" in

    "-m")

	multirun=passed
	shift
	for i in $@
	do
		h4file=`echo $i | $SED -e s/\.h5/.hdf/g`

	    	actual=`echo $h4file | $SED -e s/\.hdf/.tmp/`
	    	expect=`echo $h4file | $SED -e s/\.hdf/.dmp/`

		if test "tloop.hdf" = "$h4file"; then
			($H4DUMP dumpvg "$OUTDIR/$h4file" |head -50 >"$OUTDIR/$actual") 2>/dev/null
		else
			$H4DUMP dumpvg "$OUTDIR/$h4file" > "$OUTDIR/$actual"
		fi
		$H4DUMP dumpvd "$OUTDIR/$h4file" >> "$OUTDIR/$actual"
		$H4DUMP dumpsds "$OUTDIR/$h4file" >> "$OUTDIR/$actual"

    		# Results. We normalize the result to account for different output 
    		# widths.  That is, the test should succeed if the only
    		# differences are in white space. We have to do this the hard way
    		# because diff isn't always smart enough.
		tr '\n' ' ' <"$OUTDIR/$actual" |tr -s ' \t' |fold >"$OUTDIR/$actual-norm"
		tr '\n' ' ' <"$INDIR/$expect" |tr -s ' \t' |fold >"$OUTDIR/$expect-norm"

    		if $cmp "$OUTDIR/$expect-norm" "$OUTDIR/$actual-norm"; then
			set unrelated
		else
			if test "passed" = "$multirun"; then
				echo "*FAILED*"
				echo "    Actual result (*.tmp) differs from expected result (*.dmp)"
				nerrors="`expr $nerrors + 1`"
				multirun=failed
			fi
			test yes = "$verbose" && $diff "$INDIR/$expect" "$OUTDIR/$actual" |sed 's/^/    /'
    		fi

    		# Clean up output file
    		$RM "$OUTDIR/$expect-norm" "$OUTDIR/$actual-norm"
    		if [ X = ${HDF5_NOCLEANUP:-X} ]; then
			$RM "$OUTDIR/$actual"
			$RM "$OUTDIR/$h4file"
    		fi
	done
	if test "passed" = "$multirun"; then
		echo " PASSED"
	fi

	;;


    * )

   	if [ $# -eq 1 ]
	then 
		h4file=`echo $1 | $SED -e s/\.h5/.hdf/`
	else
		h4file=$2
	fi

	actual=`echo $h4file | $SED -e s/\.hdf/.tmp/`
	expect=`echo $h4file | $SED -e s/\.hdf/.dmp/`

	if test "tloop.hdf" = "$h4file"; then
		($H4DUMP dumpvg "$OUTDIR/$h4file" |head -50 >"$OUTDIR/$actual") 2>/dev/null
	else
		$H4DUMP dumpvg "$OUTDIR/$h4file" > "$OUTDIR/$actual"
	fi
	$H4DUMP dumpvd "$OUTDIR/$h4file" >> "$OUTDIR/$actual"
	$H4DUMP dumpsds "$OUTDIR/$h4file" >> "$OUTDIR/$actual"


	# Results. We normalize the result to account for different output 
	# widths.  That is, the test should succeed if the only
	# differences are in white space. We have to do this the hard way
	# because diff isn't always smart enough.
	tr '\n' ' ' <"$OUTDIR/$actual" |tr -s ' \t' |fold >"$OUTDIR/$actual-norm"
	tr '\n' ' ' <"$INDIR/$expect" |tr -s ' \t' |fold >"$OUTDIR/$expect-norm"

	if $cmp "$OUTDIR/$expect-norm" "$OUTDIR/$actual-norm"; then
		echo " PASSED"
	else
		echo "*FAILED*"
		echo "    Actual result (*.tmp) differs from expected result (*.dmp)"
		nerrors="`expr $nerrors + 1`"
		test yes = "$verbose" && $diff "$INDIR/$expect" "$OUTDIR/$actual" |sed 's/^/    /'
	fi

	# Clean up output file
	$RM "$OUTDIR/$expect-norm" "$OUTDIR/$actual-norm"
	if [ X = ${HDF5_NOCLEANUP:-X} ]; then
		$RM "$OUTDIR/$actual"
		$RM "$OUTDIR/$h4file"
	fi
	;;

    esac

}



##############################################################################
##############################################################################
###			  T H E   T E S T S                                ###
##############################################################################
##############################################################################

$RM $OUTDIR/*.hdf $OUTDIR/*.tmp

#
# The HDF4 filenames are created based upon the HDF5 filenames
# without the extension.
#

# test for converting H5 groups to H4 Vgroups.
CONVERT tgroup.h5

# test for converting H5 datasets to H4 SDS's.
CONVERT tdset.h5

# test for converting H5 attributes to H4 attributes.
CONVERT tattr.h5

# test for converting H5 soft links.
CONVERT tslink.h5

# test for converting H5 hard links.
CONVERT thlink.h5

# test for converting H5 compound data type to H4 Vdata.
CONVERT tcompound.h5

# test for converting all H5 objects at in same file.
CONVERT tall.h5

# tests for converting H5 objects with loops.
CONVERT tloop.h5

# test for converting extendable H5 datasets to H4 SDS's.
CONVERT tdset2.h5

# test for converting extendable H5 datasets with compound data type to H4 Vdata.
CONVERT tcompound2.h5

# tests for converting H5 objects from many different pathways.
CONVERT tmany.h5

# tests for converting H5 string objects.
CONVERT tstr.h5

# tests for converting more H5 string objects.
CONVERT tstr2.h5

#
# The test for conversion are the same as above with the only difference
# being that the HDF4 filenames are given explicitly.
#

$RM $OUTDIR/*.tmp
CONVERT tgroup.h5 tgroup.hdf
CONVERT tdset.h5 tdset.hdf
CONVERT tattr.h5 tattr.hdf
CONVERT tslink.h5 tslink.hdf
CONVERT thlink.h5 thlink.hdf
CONVERT tcompound.h5 tcompound.hdf
CONVERT tall.h5 tall.hdf
CONVERT tloop.h5 tloop.hdf
CONVERT tdset2.h5 tdset2.hdf
CONVERT tcompound2.h5 tcompound2.hdf
CONVERT tmany.h5 tmany.hdf
CONVERT tstr.h5 tstr.hdf
CONVERT tstr2.h5 tstr2.hdf

#
# Again, the test for conversion are the same as the first set of test.
# Here, multiple conversion are done on HDF5 files at one time.
#

$RM $OUTDIR/*.hdf $OUTDIR/*.tmp
CONVERT -m tgroup.h5 tdset.h5 tattr.h5 tslink.h5 thlink.h5
CONVERT -m tcompound.h5 tall.h5 tloop.h5
CONVERT -m tdset2.h5 tcompound2.h5 tmany.h5
CONVERT -m tstr.h5 tstr2.h5

if test $nerrors -eq 0 ; then
	echo "All h5toh4 tests passed."
fi

exit $nerrors