core/sql/regress/tools/runregr_privs1.ksh - trafodion - Git at Google

 #######################################################################
 # @@@ START COPYRIGHT @@@
 #
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
 # regarding copyright ownership.  The ASF licenses this file
 # to you under the Apache License, Version 2.0 (the
 # "License"); you may not use this file except in compliance
 # with the License.  You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing,
 # software distributed under the License is distributed on an
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
 #
 # @@@ END COPYRIGHT @@@
 #######################################################################


 ################################################################################
 #                     PRIVS1 REGRESSION TEST SUITE                             #
 #                                                                              #
 # This script automates the running of privilege security tests                #
 #                                                                              #
 ################################################################################

 #! /bin/sh

 #  The command set -x, makes the script echo everything.  Useful for debugging
 #set -x

 #------------------------------------------------------
 #  User asked for help text (-h, -help or -? option) --
 # print it out and exit.                             --
 #------------------------------------------------------
 function usage {
   echo ""
   echo "Description: executes privilege tests"
   echo ""
   echo "  [-help | -h | -?]    -- this text "
   echo "  [-dircleanup]        -- cleanup directory "
   echo "  [-diff]              -- do not run, only do diffs "
   echo "  [<priv tests>]       -- run the specified tests "
   echo ""
   echo "If no options specified, run all tests and perform diffs"
   echo " "
 }

 #-----------------------------------------------------------------
 #  Each command line option has an associated boolean variable  --
 # indicating whether or not the option is in effect.  Initalize --
 # these booleans to false.                                      --
 #-----------------------------------------------------------------
 diffsonly=0
 dircleanup=0

 echo ""
 echo "RUNNING PRIVS1 TESTS"
 echo ""
 #--------------------------------------------------------------
 #  Determine which command line arguments the user specified --
 # and set the corresponding boolean variable to TRUE.        --
 #--------------------------------------------------------------
 OK=-1
 while [ $OK -ne 0 ]; do		# loop to allow options to appear in any order

   if [ $OK -gt 0 ]; then
     shift $OK
   fi
   OK=0

   if [ "$1" = "-dircleanup" ]; then
     dircleanup=1
     OK=1
   fi

   if [ "$1" = "-diff" ]; then
     diffsonly=1
     OK=1
   fi

   if [ "$1" = "-help" -o "$1" =  "-h" ]; then
     usage
     exit 0
     OK=1
   fi
 done

 #########################################################################
 # E N D   O F   P A R S I N G   C O M M A N D   L I N E   O P T I O N S #
 #########################################################################


 #----------------------------------------------------------------------
 #  User specified -dircleanup option.  Delete transient files and exit. --
 #----------------------------------------------------------------------
 if [ $dircleanup -eq 1 ]; then
   echo "Cleaning up directory and exiting"
   cd $REGRTSTDIR 2>$NULL
   rm -f core dumpfile *.srt *.flt *.tflt
   cd $REGRRUNDIR 2>$NULL
   rm -f core dumpfile *.srt *.flt *.tflt
   exit 0
 fi

 #---------------------------------------------------------------------
 # Initialize variables used in the test                             --
 #---------------------------------------------------------------------

 PRIVSDIR=${rundir}/privs1
 sbdefsfile="$REGRTOOLSDIR/sbdefs"
 export BUILD_FLAVOR=`echo $BUILD_FLAVOR | tr a-z A-Z`
 echo "build flavor: $BUILD_FLAVOR"

 seabase="$SEABASE_REGRESS"

 # set up default catalog and schema
 export TEST_CATALOG='TRAFODION'
 export TEST_SCHEMA_NAME='sch'
 export TEST_SCHEMA="$TEST_CATALOG.$TEST_SCHEMA_NAME"
 echo "test catalog and schema: $TEST_SCHEMA"

 cd $REGRTSTDIR 2>$NULL
 echo "current work directory: `pwd`"

 #---------------------------------------------------------------------
 # uppercase all test, expected, known, filter, and diff files       --
 #---------------------------------------------------------------------
 lctestfiles=`ls -1 test???* 2>$NULL | sed -e /~$/d -e /.bak$/d | \
                sort -fu | pr  -a -h "" -w 9999 -l 1` 2>$NULL
 for lcfile in $lctestfiles; do
   ucfile=`ls -1 $lcfile | tr a-z A-Z`
   cp -f $lcfile $ucfile 2>$NULL
 done

 lcxptdfiles=`ls -1 expected???* 2>$NULL | sed -e /~$/d -e /.bak$/d | \
                sort -fu | pr  -a -h "" -w 9999 -l 1` 2>$NULL
 for lcfile in $lcxptdfiles; do
   ucfile=`ls -1 $lcfile | tr a-z A-Z`
   cp -f $lcfile $ucfile 2>$NULL
 done

 lcknownfiles=`ls -1 *.known* 2>$NULL | sed -e /~$/d -e /.bak$/d | \
                sort -fu | pr  -a -h "" -w 9999 -l 1` 2>$NULL
 for lcfile in $lcknownfiles; do
   ucfile=`ls -1 $lcfile | tr a-z A-Z`
   cp -f $lcfile $ucfile 2>$NULL
 done

 lcfilterfiles=`ls -1 filter???* 2>$NULL | sed -e /~$/d -e /.bak$/d | \
                sort -fu | pr  -a -h "" -w 9999 -l 1` 2>$NULL
 for lcfile in $lcfilterfiles; do
   ucfile=`ls -1 $lcfile | tr a-z A-Z`
   cp -f $lcfile $ucfile 2>$NULL
 done

 #--------------------------------------------------
 # Based on the command lines options specified,  --
 # determine which test files to run.             --
 # Grab either the list of specified tests or all --
 # the tests beginnning with "TEST".              --
 # If only the number is specified, prepend TEST. --
 #--------------------------------------------------
 if [ "$1" = "" ]; then
   testfiles=`ls -1 TEST???* | tr a-z A-Z | sed -e /~$/d -e /.bak$/d | sort -fu`
   prettyfiles=$testfiles
 else
   testfiles=`echo $* | tr a-z A-Z`
   prettyfiles=
   for i in $testfiles; do
     if [ `expr substr $i 1 4` = "TEST" ]; then
       prettyfiles="$prettyfiles $i"
     else
       prettyfiles="$prettyfiles TEST$i"
     fi
   done
 fi

 #-------------------------------------------------------
 # For now, don't run these tests                      --
 # Add list of tests to script in "skipTheseTests"     --
 #-------------------------------------------------------
 skipTheseTests="TEST133"

 #skip checkTest tests if they have already been run
 if [ "$CHECK_TEST2" == "1" ]; then
     skipTheseTests="$skipTheseTests $privs1CT"
 fi

 testfiles="$prettyfiles"
 prettyfiles=
 skippedfiles=
 for i in $testfiles; do
   skipthis=0
   for j in $skipTheseTests; do
     if [ "$i" = "$j" ]; then
       skipthis=1
     fi
   done

   if [ $skipthis -eq 0 ]; then
     prettyfiles="$prettyfiles $i"
   else
     skippedfiles="$skippedfiles $i"
   fi
 done
 testfiles=$prettyfiles


 #-----------------------------------------
 #  Inform user which tests will be run. --
 #-----------------------------------------
 echo "TESTS TO BE RUN: $testfiles"
 if [ "$skippedfiles" != "" ]; then
   echo "TESTS NOT RUN: $skippedfiles"
 fi

 #--------------------------------------------------
 #  Set up environment variables for running SQL. --
 #--------------------------------------------------
 cd $REGRRUNDIR 2>$NULL


 #--------------------------------------------------
 #  If the user did not choose the -diff option,  --
 # rename the old log file to have a .bak suffix. --
 # Write date and time to new log file.           --
 #--------------------------------------------------
 test $diffsonly -eq 0 && mv -f $rgrlog $rgrlog.bak 2>$NULL
 echo "`date +'%D %T'`" > $rgrlog

 #---------------------------------------
 #  For each test file in the list.... --
 #---------------------------------------
 for ix in $testfiles; do

   #---------------------------------------
   #  Tell user whether we're just doing --
   # diffs or actually running a test.   --
   #---------------------------------------
   echo
   if [ $diffsonly -eq 1 ]; then
     echo "------------------------------------------------------------"
     echo "-- Doing diff for test $ix: "
     echo "------------------------------------------------------------"
   else
     echo "------------------------------------------------------------"
     echo "-- Starting test $ix: "
     echo "------------------------------------------------------------"
   fi
   echo

   #---------------------------------------------------------
   #  Set up the test file, expected file, output file and --
   # difference file names for this iteration.  Also clear --
   # out the log text for the current iteration.           --
   #---------------------------------------------------------
   tnum=`echo $ix | cut -c 5-`
   exp=EXPECTED$tnum
   diff=DIFF$tnum
   tfile=$REGRTSTDIR/$ix
   dfile=$REGRRUNDIR/$diff
   lfile=$REGRRUNDIR/LOG$tnum
   logtxt=
   runTheTest=1

   # --------------------------------------------------------
   # set up expected results file                          __
   #---------------------------------------------------------

   # if EXPECTED.SB exists, use that
   if [ -r "$REGRTSTDIR/${exp}.SB" ]; then
       exp="${exp}.SB"
   fi
   echo "Using expected result file: $exp"

   # If a special file is needed for the release version, use it
   if [ "$BUILD_FLAVOR" = "RELEASE" ]; then
     if [ -r $REGRTSTDIR/$exp.L$BUILD_FLAVOR ]; then
       exp=$exp.L$BUILD_FLAVOR
     fi
   fi

   # use the default expected file
   if [ -r "$REGRTSTDIR/$exp" ]; then
     efile=$REGRTSTDIR/$exp
   fi

   if [ $diffsonly -eq 0 ]; then
     sqlci -i $scriptsdir/tools/reg_users.sql;
     echo "Authorization has been enabled"
   fi

   #--------------------------------------------------
   # Run test if the -diff option not specified     --
   #--------------------------------------------------
   if [ $diffsonly -eq 0 ]; then
     if [ $runTheTest -eq 1 ]; then
       rm -f $lfile.BAK $dfile.BAK 2>$NULL
       mv -f $lfile $lfile.BAK 2>$NULL
       mv -f $dfile $dfile.BAK 2>$NULL

       if [ "$REGRTSTDIR" != "$REGRRUNDIR" ]; then
          cp -f $REGRTSTDIR/$ix $REGRRUNDIR/$ix 2>$NULL
       fi

       echo "Executing: $sqlci -i$tfile"
       $sqlci -i$tfile

       if [ "$REGRTSTDIR" != "$REGRRUNDIR" ]; then
          rm -f $REGRRUNDIR/$ix 2>$NULL
       fi
     fi
   else
     rm -f $dfile.BAK
     mv -f $dfile $dfile.BAK
   fi

   #---------------------------------------
   #  Sort log and expected result file. --
   #---------------------------------------
   if [ -x $LOGSORT ]; then
     efilesrt=$exp.srt
     lfilesrt=$lfile.srt
     rm -f $efilesrt $lfilesrt
     echo
     echo "SORTING EXPECTED AND LOG FILES"
     echo "$LOGSORT $efile $efilesrt"
     echo "$LOGSORT $lfile $lfilesrt"
     echo
     $LOGSORT $efile $efilesrt >> $NULL    # not to $diff, because
     $LOGSORT $lfile $lfilesrt >> $NULL    # logsort writes too much junk
   else
     efilesrt=$efile
     lfilesrt=$lfile
     echo "Could not find $LOGSORT, comparing unsorted files"
   fi

   #------------------------------
   # filter result files        --
   #------------------------------

   # If special filter file exist for test, run it
   if [ -x "$REGRTSTDIR/FILTER$tnum" -a -s "$REGRTSTDIR/FILTER$tnum" ]; then
     efiletflt=$exp.tflt
     lfiletflt=$lfile.tflt
     rm -f $efiletflt $lfiletflt
     echo "RUNNING SPECIAL FILTER FOR TEST $tnum"
     echo "Special filtering expected file"
     echo "$REGRTSTDIR/FILTER$tnum $efilesrt > $efiletflt"
     echo "Special filtering log file"
     echo "$REGRTSTDIR/FILTER$tnum $lfilesrt > $lfiletflt"
     echo
     $REGRTSTDIR/FILTER$tnum $efilesrt > $efiletflt 2>&1
     $REGRTSTDIR/FILTER$tnum $lfilesrt > $lfiletflt 2>&1
   else
     efiletflt=$efilesrt
     lfiletflt=$lfilesrt
   fi

   # Run general filter file common for all tests
   echo "RUNNING STANDARD FILTER FILE ON SORTED OUTPUT"
   rm -f $exp.flt $lfile.flt
   echo "Filtering expected file:"
   echo "$FILTER $efiletflt > $exp.flt"
   echo "Filtering log file:"
   echo "$FILTER $lfiletflt > $lfile.flt"
   echo
   $FILTER $efiletflt > $exp.flt 2>&1
   $FILTER $lfiletflt > $lfile.flt 2>&1

   #----------------------------------------------------------------
   #  Capture filtered files                              --
   #----------------------------------------------------------------
   echo
   echo "RETAINING RESULTS OF FILTER OPERATION"
   echo "Saving filtered expected files:"
   echo "cp $exp.flt $FilteredLogs/expfiles/LOG$tnum"
   cp $exp.flt $FilteredLogs/expfiles/LOG$tnum
   echo "Saving filtered log files:"
   echo "cp $lfile.flt $FilteredLogs/logfiles/LOG$tnum"
   cp $lfile.flt $FilteredLogs/logfiles/LOG$tnum

   #----------------------------------------------------------------
   #  Compare filtered expected and actual files for differences. --
   #----------------------------------------------------------------
   echo
   echo "RUNNING DIFFs ON SORTED AND FILTERED LOGS/EXPECTED FILES"
   echo "diff $exp.flt $lfile.flt >> $dfile"
   echo
   if [ -z "$DUMA_FILL" ] ; then
     diff $exp.flt $lfile.flt >> $dfile 2>&1
   else
     diff $exp.flt $lfile.flt >> $dfile 2>/dev/null
   fi


   #rm -f $efilesrt $lfilesrt $efile.flt $lfile.flt $efiletflt $lfiletflt 2>$NULL

   #------------------------------------------
   #  Determine how many lines differed     --
   # between the expected and actual files. --
   #------------------------------------------
   diffsize=`wc -l $dfile`; diffsize=`echo $diffsize | cut -f1 -d' '`

   #-----------------------------------------------------------------
   # Compare with the known diff file to see if differences are ok --
   #-----------------------------------------------------------------
    diffsAreKnown=0
    diffknownfile=
    knownsize=
    if [ $diffsize -ne 0 ]; then
        if [ -r         $REGRRUNDIR/$diff.KNOWN.$BUILD_FLAVOR ]; then
          diffknownfile=$REGRRUNDIR/$diff.KNOWN.$BUILD_FLAVOR
        elif [ -r       $REGRTSTDIR/$diff.KNOWN ]; then
          diffknownfile=$REGRTSTDIR/$diff.KNOWN
        fi
    fi

     #  Diff the diff and the diff.known files and see how many lines differ
     if [ "$diffknownfile" != "" ]; then
       echo
       echo "COMPARING KNOWN DIFFS FILE TO CURRENT DIFFS"
       echo "Size of diff file: $diffsize"
       # Filter known diff file to avoid schema differences
       knownfiltered="$(dirname $dfile)/$(basename $diffknownfile).flt"
       dfilefiltered="$dfile.flt"
       echo "Filtering known diff file: "
       echo "$FILTER $diffknownfile > $knownfiltered 2>&1"
       $FILTER $diffknownfile > $knownfiltered 2>&1
       echo "Filtering diff file: "
       echo "$FILTER $dfile > $dfilefiltered 2>&1"
       $FILTER $dfile > $dfilefiltered 2>&1
       echo "Performing the DIFF: "
       echo "diff $dfilefiltered $knownfiltered 2>&1"
       diff $dfilefiltered $knownfiltered > $NULL
       if [ $? -eq 0 ]; then
         diffsAreKnown=1
       else
         ktmp=`wc -l $knownfiltered`; ktmp=`echo $ktmp | cut -f1 -d' '`
         test "$ktmp" != "" &&
         test $ktmp -ne 0 && knownsize=" (vs. $ktmp known)"
       fi
     fi

   #--------------------------
   #  Print result of test. --
   #--------------------------
   if [ $diffsize -eq 0 -o $diffsAreKnown -ne 0 ]; then
     if [ $diffsize -eq 0 ]; then
       logtxt="### PASS ###$logtxt"
     else
       logtxt="### PASS with known diffs ###"
     fi
   else
     logtxt="### FAIL ($diffsize lines$knownsize)     ###"
   fi


   #-------------------------------------------------------------
   #  Print date, time, test name and test result in log file. --
   #-------------------------------------------------------------
   echo $logtxt
   modtime=`stat --printf=%y $lfile | cut -d'.' -f1`
   echo "$modtime  $ix  $logtxt" >> $rgrlog

 done

 #----------------------------------------
 #  Print log file to screen            --
 #----------------------------------------
 echo
 echo
 echo 'Test Summary'
 echo '============'
 echo
 cat $rgrlog
 echo

 #------------------------
 # Clean up dump files. --
 #------------------------
 rm -f core dumpfile 2>$NULL
 #rm -f $REGRRUNDIR/runmxci.ksh 2>$NULL
 rm -f $REGRRUNDIR/tmpfile.*.log 2>$NULL
	#######################################################################
	# @@@ START COPYRIGHT @@@
	#
	# Licensed to the Apache Software Foundation (ASF) under one
	# or more contributor license agreements. See the NOTICE file
	# distributed with this work for additional information
	# regarding copyright ownership. The ASF licenses this file
	# to you under the Apache License, Version 2.0 (the
	# "License"); you may not use this file except in compliance
	# with the License. You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing,
	# software distributed under the License is distributed on an
	# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	# KIND, either express or implied. See the License for the
	# specific language governing permissions and limitations
	# under the License.
	#
	# @@@ END COPYRIGHT @@@
	#######################################################################


	################################################################################
	# PRIVS1 REGRESSION TEST SUITE #
	# #
	# This script automates the running of privilege security tests #
	# #
	################################################################################

	#! /bin/sh

	# The command set -x, makes the script echo everything. Useful for debugging
	#set -x

	#------------------------------------------------------
	# User asked for help text (-h, -help or -? option) --
	# print it out and exit. --
	#------------------------------------------------------
	function usage {
	echo ""
	echo "Description: executes privilege tests"
	echo ""
	echo " [-help \| -h \| -?] -- this text "
	echo " [-dircleanup] -- cleanup directory "
	echo " [-diff] -- do not run, only do diffs "
	echo " [<priv tests>] -- run the specified tests "
	echo ""
	echo "If no options specified, run all tests and perform diffs"
	echo " "
	}

	#-----------------------------------------------------------------
	# Each command line option has an associated boolean variable --
	# indicating whether or not the option is in effect. Initalize --
	# these booleans to false. --
	#-----------------------------------------------------------------
	diffsonly=0
	dircleanup=0

	echo ""
	echo "RUNNING PRIVS1 TESTS"
	echo ""
	#--------------------------------------------------------------
	# Determine which command line arguments the user specified --
	# and set the corresponding boolean variable to TRUE. --
	#--------------------------------------------------------------
	OK=-1
	while [ $OK -ne 0 ]; do # loop to allow options to appear in any order

	if [ $OK -gt 0 ]; then
	shift $OK
	fi
	OK=0

	if [ "$1" = "-dircleanup" ]; then
	dircleanup=1
	OK=1
	fi

	if [ "$1" = "-diff" ]; then
	diffsonly=1
	OK=1
	fi

	if [ "$1" = "-help" -o "$1" = "-h" ]; then
	usage
	exit 0
	OK=1
	fi
	done

	#########################################################################
	# E N D O F P A R S I N G C O M M A N D L I N E O P T I O N S #
	#########################################################################


	#----------------------------------------------------------------------
	# User specified -dircleanup option. Delete transient files and exit. --
	#----------------------------------------------------------------------
	if [ $dircleanup -eq 1 ]; then
	echo "Cleaning up directory and exiting"
	cd $REGRTSTDIR 2>$NULL
	rm -f core dumpfile .srt .flt *.tflt
	cd $REGRRUNDIR 2>$NULL
	rm -f core dumpfile .srt .flt *.tflt
	exit 0
	fi

	#---------------------------------------------------------------------
	# Initialize variables used in the test --
	#---------------------------------------------------------------------

	PRIVSDIR=${rundir}/privs1
	sbdefsfile="$REGRTOOLSDIR/sbdefs"
	export BUILD_FLAVOR=`echo $BUILD_FLAVOR \| tr a-z A-Z`
	echo "build flavor: $BUILD_FLAVOR"

	seabase="$SEABASE_REGRESS"

	# set up default catalog and schema
	export TEST_CATALOG='TRAFODION'
	export TEST_SCHEMA_NAME='sch'
	export TEST_SCHEMA="$TEST_CATALOG.$TEST_SCHEMA_NAME"
	echo "test catalog and schema: $TEST_SCHEMA"

	cd $REGRTSTDIR 2>$NULL
	echo "current work directory: `pwd`"

	#---------------------------------------------------------------------
	# uppercase all test, expected, known, filter, and diff files --
	#---------------------------------------------------------------------
	lctestfiles=`ls -1 test???* 2>$NULL \| sed -e /~$/d -e /.bak$/d \| \
	sort -fu \| pr -a -h "" -w 9999 -l 1` 2>$NULL
	for lcfile in $lctestfiles; do
	ucfile=`ls -1 $lcfile \| tr a-z A-Z`
	cp -f $lcfile $ucfile 2>$NULL
	done

	lcxptdfiles=`ls -1 expected???* 2>$NULL \| sed -e /~$/d -e /.bak$/d \| \
	sort -fu \| pr -a -h "" -w 9999 -l 1` 2>$NULL
	for lcfile in $lcxptdfiles; do
	ucfile=`ls -1 $lcfile \| tr a-z A-Z`
	cp -f $lcfile $ucfile 2>$NULL
	done

	lcknownfiles=`ls -1 .known 2>$NULL \| sed -e /~$/d -e /.bak$/d \| \
	sort -fu \| pr -a -h "" -w 9999 -l 1` 2>$NULL
	for lcfile in $lcknownfiles; do
	ucfile=`ls -1 $lcfile \| tr a-z A-Z`
	cp -f $lcfile $ucfile 2>$NULL
	done

	lcfilterfiles=`ls -1 filter???* 2>$NULL \| sed -e /~$/d -e /.bak$/d \| \
	sort -fu \| pr -a -h "" -w 9999 -l 1` 2>$NULL
	for lcfile in $lcfilterfiles; do
	ucfile=`ls -1 $lcfile \| tr a-z A-Z`
	cp -f $lcfile $ucfile 2>$NULL
	done

	#--------------------------------------------------
	# Based on the command lines options specified, --
	# determine which test files to run. --
	# Grab either the list of specified tests or all --
	# the tests beginnning with "TEST". --
	# If only the number is specified, prepend TEST. --
	#--------------------------------------------------
	if [ "$1" = "" ]; then
	testfiles=`ls -1 TEST???* \| tr a-z A-Z \| sed -e /~$/d -e /.bak$/d \| sort -fu`
	prettyfiles=$testfiles
	else
	testfiles=`echo $* \| tr a-z A-Z`
	prettyfiles=
	for i in $testfiles; do
	if [ `expr substr $i 1 4` = "TEST" ]; then
	prettyfiles="$prettyfiles $i"
	else
	prettyfiles="$prettyfiles TEST$i"
	fi
	done
	fi

	#-------------------------------------------------------
	# For now, don't run these tests --
	# Add list of tests to script in "skipTheseTests" --
	#-------------------------------------------------------
	skipTheseTests="TEST133"

	#skip checkTest tests if they have already been run
	if [ "$CHECK_TEST2" == "1" ]; then
	skipTheseTests="$skipTheseTests $privs1CT"
	fi

	testfiles="$prettyfiles"
	prettyfiles=
	skippedfiles=
	for i in $testfiles; do
	skipthis=0
	for j in $skipTheseTests; do
	if [ "$i" = "$j" ]; then
	skipthis=1
	fi
	done

	if [ $skipthis -eq 0 ]; then
	prettyfiles="$prettyfiles $i"
	else
	skippedfiles="$skippedfiles $i"
	fi
	done
	testfiles=$prettyfiles


	#-----------------------------------------
	# Inform user which tests will be run. --
	#-----------------------------------------
	echo "TESTS TO BE RUN: $testfiles"
	if [ "$skippedfiles" != "" ]; then
	echo "TESTS NOT RUN: $skippedfiles"
	fi

	#--------------------------------------------------
	# Set up environment variables for running SQL. --
	#--------------------------------------------------
	cd $REGRRUNDIR 2>$NULL


	#--------------------------------------------------
	# If the user did not choose the -diff option, --
	# rename the old log file to have a .bak suffix. --
	# Write date and time to new log file. --
	#--------------------------------------------------
	test $diffsonly -eq 0 && mv -f $rgrlog $rgrlog.bak 2>$NULL
	echo "`date +'%D %T'`" > $rgrlog

	#---------------------------------------
	# For each test file in the list.... --
	#---------------------------------------
	for ix in $testfiles; do

	#---------------------------------------
	# Tell user whether we're just doing --
	# diffs or actually running a test. --
	#---------------------------------------
	echo
	if [ $diffsonly -eq 1 ]; then
	echo "------------------------------------------------------------"
	echo "-- Doing diff for test $ix: "
	echo "------------------------------------------------------------"
	else
	echo "------------------------------------------------------------"
	echo "-- Starting test $ix: "
	echo "------------------------------------------------------------"
	fi
	echo

	#---------------------------------------------------------
	# Set up the test file, expected file, output file and --
	# difference file names for this iteration. Also clear --
	# out the log text for the current iteration. --
	#---------------------------------------------------------
	tnum=`echo $ix \| cut -c 5-`
	exp=EXPECTED$tnum
	diff=DIFF$tnum
	tfile=$REGRTSTDIR/$ix
	dfile=$REGRRUNDIR/$diff
	lfile=$REGRRUNDIR/LOG$tnum
	logtxt=
	runTheTest=1

	# --------------------------------------------------------
	# set up expected results file __
	#---------------------------------------------------------

	# if EXPECTED.SB exists, use that
	if [ -r "$REGRTSTDIR/${exp}.SB" ]; then
	exp="${exp}.SB"
	fi
	echo "Using expected result file: $exp"

	# If a special file is needed for the release version, use it
	if [ "$BUILD_FLAVOR" = "RELEASE" ]; then
	if [ -r $REGRTSTDIR/$exp.L$BUILD_FLAVOR ]; then
	exp=$exp.L$BUILD_FLAVOR
	fi
	fi

	# use the default expected file
	if [ -r "$REGRTSTDIR/$exp" ]; then
	efile=$REGRTSTDIR/$exp
	fi

	if [ $diffsonly -eq 0 ]; then
	sqlci -i $scriptsdir/tools/reg_users.sql;
	echo "Authorization has been enabled"
	fi

	#--------------------------------------------------
	# Run test if the -diff option not specified --
	#--------------------------------------------------
	if [ $diffsonly -eq 0 ]; then
	if [ $runTheTest -eq 1 ]; then
	rm -f $lfile.BAK $dfile.BAK 2>$NULL
	mv -f $lfile $lfile.BAK 2>$NULL
	mv -f $dfile $dfile.BAK 2>$NULL

	if [ "$REGRTSTDIR" != "$REGRRUNDIR" ]; then
	cp -f $REGRTSTDIR/$ix $REGRRUNDIR/$ix 2>$NULL
	fi

	echo "Executing: $sqlci -i$tfile"
	$sqlci -i$tfile

	if [ "$REGRTSTDIR" != "$REGRRUNDIR" ]; then
	rm -f $REGRRUNDIR/$ix 2>$NULL
	fi
	fi
	else
	rm -f $dfile.BAK
	mv -f $dfile $dfile.BAK
	fi

	#---------------------------------------
	# Sort log and expected result file. --
	#---------------------------------------
	if [ -x $LOGSORT ]; then
	efilesrt=$exp.srt
	lfilesrt=$lfile.srt
	rm -f $efilesrt $lfilesrt
	echo
	echo "SORTING EXPECTED AND LOG FILES"
	echo "$LOGSORT $efile $efilesrt"
	echo "$LOGSORT $lfile $lfilesrt"
	echo
	$LOGSORT $efile $efilesrt >> $NULL # not to $diff, because
	$LOGSORT $lfile $lfilesrt >> $NULL # logsort writes too much junk
	else
	efilesrt=$efile
	lfilesrt=$lfile
	echo "Could not find $LOGSORT, comparing unsorted files"
	fi

	#------------------------------
	# filter result files --
	#------------------------------

	# If special filter file exist for test, run it
	if [ -x "$REGRTSTDIR/FILTER$tnum" -a -s "$REGRTSTDIR/FILTER$tnum" ]; then
	efiletflt=$exp.tflt
	lfiletflt=$lfile.tflt
	rm -f $efiletflt $lfiletflt
	echo "RUNNING SPECIAL FILTER FOR TEST $tnum"
	echo "Special filtering expected file"
	echo "$REGRTSTDIR/FILTER$tnum $efilesrt > $efiletflt"
	echo "Special filtering log file"
	echo "$REGRTSTDIR/FILTER$tnum $lfilesrt > $lfiletflt"
	echo
	$REGRTSTDIR/FILTER$tnum $efilesrt > $efiletflt 2>&1
	$REGRTSTDIR/FILTER$tnum $lfilesrt > $lfiletflt 2>&1
	else
	efiletflt=$efilesrt
	lfiletflt=$lfilesrt
	fi

	# Run general filter file common for all tests
	echo "RUNNING STANDARD FILTER FILE ON SORTED OUTPUT"
	rm -f $exp.flt $lfile.flt
	echo "Filtering expected file:"
	echo "$FILTER $efiletflt > $exp.flt"
	echo "Filtering log file:"
	echo "$FILTER $lfiletflt > $lfile.flt"
	echo
	$FILTER $efiletflt > $exp.flt 2>&1
	$FILTER $lfiletflt > $lfile.flt 2>&1

	#----------------------------------------------------------------
	# Capture filtered files --
	#----------------------------------------------------------------
	echo
	echo "RETAINING RESULTS OF FILTER OPERATION"
	echo "Saving filtered expected files:"
	echo "cp $exp.flt $FilteredLogs/expfiles/LOG$tnum"
	cp $exp.flt $FilteredLogs/expfiles/LOG$tnum
	echo "Saving filtered log files:"
	echo "cp $lfile.flt $FilteredLogs/logfiles/LOG$tnum"
	cp $lfile.flt $FilteredLogs/logfiles/LOG$tnum

	#----------------------------------------------------------------
	# Compare filtered expected and actual files for differences. --
	#----------------------------------------------------------------
	echo
	echo "RUNNING DIFFs ON SORTED AND FILTERED LOGS/EXPECTED FILES"
	echo "diff $exp.flt $lfile.flt >> $dfile"
	echo
	if [ -z "$DUMA_FILL" ] ; then
	diff $exp.flt $lfile.flt >> $dfile 2>&1
	else
	diff $exp.flt $lfile.flt >> $dfile 2>/dev/null
	fi


	#rm -f $efilesrt $lfilesrt $efile.flt $lfile.flt $efiletflt $lfiletflt 2>$NULL

	#------------------------------------------
	# Determine how many lines differed --
	# between the expected and actual files. --
	#------------------------------------------
	diffsize=`wc -l $dfile`; diffsize=`echo $diffsize \| cut -f1 -d' '`

	#-----------------------------------------------------------------
	# Compare with the known diff file to see if differences are ok --
	#-----------------------------------------------------------------
	diffsAreKnown=0
	diffknownfile=
	knownsize=
	if [ $diffsize -ne 0 ]; then
	if [ -r $REGRRUNDIR/$diff.KNOWN.$BUILD_FLAVOR ]; then
	diffknownfile=$REGRRUNDIR/$diff.KNOWN.$BUILD_FLAVOR
	elif [ -r $REGRTSTDIR/$diff.KNOWN ]; then
	diffknownfile=$REGRTSTDIR/$diff.KNOWN
	fi
	fi

	# Diff the diff and the diff.known files and see how many lines differ
	if [ "$diffknownfile" != "" ]; then
	echo
	echo "COMPARING KNOWN DIFFS FILE TO CURRENT DIFFS"
	echo "Size of diff file: $diffsize"
	# Filter known diff file to avoid schema differences
	knownfiltered="$(dirname $dfile)/$(basename $diffknownfile).flt"
	dfilefiltered="$dfile.flt"
	echo "Filtering known diff file: "
	echo "$FILTER $diffknownfile > $knownfiltered 2>&1"
	$FILTER $diffknownfile > $knownfiltered 2>&1
	echo "Filtering diff file: "
	echo "$FILTER $dfile > $dfilefiltered 2>&1"
	$FILTER $dfile > $dfilefiltered 2>&1
	echo "Performing the DIFF: "
	echo "diff $dfilefiltered $knownfiltered 2>&1"
	diff $dfilefiltered $knownfiltered > $NULL
	if [ $? -eq 0 ]; then
	diffsAreKnown=1
	else
	ktmp=`wc -l $knownfiltered`; ktmp=`echo $ktmp \| cut -f1 -d' '`
	test "$ktmp" != "" &&
	test $ktmp -ne 0 && knownsize=" (vs. $ktmp known)"
	fi
	fi

	#--------------------------
	# Print result of test. --
	#--------------------------
	if [ $diffsize -eq 0 -o $diffsAreKnown -ne 0 ]; then
	if [ $diffsize -eq 0 ]; then
	logtxt="### PASS ###$logtxt"
	else
	logtxt="### PASS with known diffs ###"
	fi
	else
	logtxt="### FAIL ($diffsize lines$knownsize) ###"
	fi


	#-------------------------------------------------------------
	# Print date, time, test name and test result in log file. --
	#-------------------------------------------------------------
	echo $logtxt
	modtime=`stat --printf=%y $lfile \| cut -d'.' -f1`
	echo "$modtime $ix $logtxt" >> $rgrlog

	done

	#----------------------------------------
	# Print log file to screen --
	#----------------------------------------
	echo
	echo
	echo 'Test Summary'
	echo '============'
	echo
	cat $rgrlog
	echo

	#------------------------
	# Clean up dump files. --
	#------------------------
	rm -f core dumpfile 2>$NULL
	#rm -f $REGRRUNDIR/runmxci.ksh 2>$NULL
	rm -f $REGRRUNDIR/tmpfile.*.log 2>$NULL