    #!/bin/sh  
# \
exec oagwish "$0" "$@"
set auto_path [linsert $auto_path 0  /usr/local/oag/apps/lib/$env(HOST_ARCH)]
set auto_path [linsert $auto_path 0 /usr/local/oag/lib_patch/$env(HOST_ARCH)] 

wm geometry . +50+10
set CVSRevisionAuthor "\$Revision: 1.43 $ \$Author: shang $"
APSApplication . \
    -name "Test SDDS Procedures" \
    -version $CVSRevisionAuthor 
set status "Ready"
APSScrolledStatus .status \
    -parent .userFrame \
    -textVariable status \
    -packOption "-expand true -fill both" \
    -width 80
update

frame .frame1
frame .frame2
frame .frame2b
frame .frame3
frame .frame4 -borderwidth 3 -relief raised
frame .frame5 
pack .frame1 .frame2 .frame2b -in .userFrame -side left
pack .frame3 -in .userFrame -side left -fill both -expand true
pack .frame5 -side top -fill both -expand true 
pack .frame4 -side top -fill x -expand true

APSButton .citi2sdds -parent .frame1 -text citi2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program citi2sdds -options "description mpllabels"}
APSButton .csv2sdds -parent .frame1 -text csv2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program csv2sdds -options "pipe asciiOutput spanLines maxRows schFile delimiters separator columnData"}
APSButton .editstring -parent .frame1 -text editstring -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program editstring -options "editcommand"}
APSButton .elegant2genesis -parent .frame1 -text elegant2genesis -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program elegant2genesis -options "totalCharge wavelength slices steer textOutput"}
APSButton .hpif2sdds -parent .frame1 -text hpif2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program hpif2sdds -options "signalname description mpllabels initialt signalprecision segmentinterval separatesegments pairs"}
APSButton .hpwf2sdds -parent .frame1 -text hpwf2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program hpwf2sdds -options "signalname description mpllabels"}
APSButton .image2sdds -parent .frame1 -text image2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program image2sdds -options "2d ascii contour  transpose xdim ydim xmin xmax ymin ymax multicolumnmode "}
APSButton .lba2sdds -parent .frame1 -text lba2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program lba2sdds -options "pipe definition"}
APSButton .mcs2sdds -parent .frame1 -text mcs2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program mcs2sdds -options "ascii"}
APSButton .mpl2sdds -parent .frame1 -text mpl2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program mpl2sdds -options "output erase binary"}
APSButton .plaindata2sdds -parent .frame1 -text plaindata2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program plaindata2sdds -options "pipe inputMode outputMode separator noRowCount order parameter column nowarnings"}
APSButton .raw2sdds -parent .frame1 -text raw2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program raw2sdds -options "definition size"}
APSButton .sdds2dinterpolate -parent .frame1 -text sdds2dinterpolate -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2dinterpolate -options "independentColumn dependentColumn scale outDimension range zoom clusterThin dimensionThin algorithm weight npoints pipe"}
APSButton .sdds2math -parent .frame1 -text sdds2math -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2math -options "pipe comments verbose format"}
APSButton .sdds2mpl -parent .frame1 -text sdds2mpl -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2mpl -options "pipe rootname output labelParameters separatePages announceOpenings"}
APSButton .sdds2plaindata -parent .frame1 -text sdds2plaindata -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2plaindata -options "pipe outputMode separator noRowCount order parameter column nowarnings"}
APSButton .sdds2spreadsheet -parent .frame1 -text sdds2spreadsheet -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2spreadsheet -options "pipe delimiter all verbose"}
APSButton .sdds2stream -parent .frame1 -text sdds2stream -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2stream -options "pipe page delimiter columns parameters filenames rows noquotes ignoreFormats"}
APSButton .sdds2tiff -parent .frame1 -text sdds2tiff -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sdds2tiff -options "pipe maxcontrast frompage topage columnPrefix 16bit"}
APSButton .sddsarray2column -parent .frame1 -text sddsarray2column -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsarray2column -options "pipe nowarnings convert"}
APSButton .sddsbaseline -parent .frame1 -text sddsbaseline -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsbaseline -options "pipe columns nonnegative despike repeats select outsideFWHA antiOutlier method"}
APSButton .sddsbinarystring -parent .frame1 -text sddsbinarystring -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsbinarystring -options "pipe column"}
APSButton .sddsbreak -parent .frame1 -text sddsbreak -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsbreak -options "pipe gapIn increaseOf decreaseOf changeOf rowLimit whentrue aftertrue"}
APSButton .sddscast -parent .frame1 -text sddscast -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscast -options "pipe cast"}
APSButton .sddschanges -parent .frame1 -text sddschanges -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddschanges -options "pipe copy changesIn baseline"}
APSButton .sddscheck -parent .frame1 -text sddscheck -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscheck -options "printErrors"}
APSButton .sddscliptails -parent .frame1 -text sddscliptails -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscliptails -options "pipe columns fractional absolute fwhm afterzero"}
APSButton .sddscollapse -parent .frame1 -text sddscollapse -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscollapse -options "pipe noWarnings"}
APSButton .sddscollect -parent .frame1 -text sddscollect -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscollect -options "pipe collect"}
APSButton .sddscombine -parent .frame1 -text sddscombine -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscombine -options "pipe merge overWrite retain"}
APSButton .sddscongen -parent .frame1 -text sddscongen -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscongen -options "xrange yrange zequation rpncommand rpndefinitions"}
APSButton .sddscontour -parent .frame1 -text sddscontour -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscontour -options "quantity equation columnMatch rpnDefinitionsFiles rpnExpressions shade mapshade contours labelContours interpolate filter xLabel yLabel title topline topTitle noLabels noScales  layout thickness dateStamp deltas logscale scales device swapxy equalAspect noBorder ystrings ticksettings output  verbosity xrange yrange"}
APSButton .sddsconvert -parent .frame2 -text sddsconvert -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsconvert -options "pipe binary ascii fromPage toPage delete retain rename editNames description recover linesPerRow noWarnings acceptAllNames"}
APSButton .sddsconvolve -parent .frame2 -text sddsconvolve -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsconvolve -options "signalColumns responseColumns outputColumns deconvolve noiseFraction correlate"}
APSButton .sddscorrelate -parent .frame2 -text sddscorrelate -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddscorrelate -options "pipe columns excludeColumns withOnly rankOrder stDevOutlier"}
APSButton .sddsderef -parent .frame2 -text sddsderef -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsderef -options "pipe column parameter constant outOfBounds"}
APSButton .sddsderiv -parent .frame2 -text sddsderiv -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsderiv -options "pipe differentiate exclude versus interval mainTemplates errorTemplates"}
APSButton .sddsdiff -parent .frame2 -text sddsdiff -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsdiff -options "compareCommon columns parameters arrays tolerance"}    
APSButton .sddsdigfilter -parent .frame2 -text sddsdigfilter -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsdigfilter -options "pipe columns proportional lowpass highpass digitalfilter analogfilter cascade verbose"}
APSButton .sddsdistest -parent .frame2 -text sddsdistest -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsdistest -options "pipe column exclude degreesOfFreedom test fileDistribution gaussian poisson student chisquared"}
APSButton .sddsduplicate -parent .frame2 -text sddsduplicate -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsduplicate -options "pipe weight maxFactor minFactor factor verbosity seed probabilistic"}
APSButton .sddsendian -parent .frame2 -text sddsendian -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsendian -options "pipe nonNative"}
APSButton .sddsenvelope -parent .frame2 -text sddsenvelope -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsenvelope -options "pipe copy maximum minimum mean rms sum standardDeviation slope intercept"}
APSButton .sddseventhist -parent .frame2 -text sddseventhist -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddseventhist -options "pipe dataColumn eventIdentifier overlapEvent bins sizeOfBins lowerLimit upperLimit sides normalize"}
APSButton .sddsexpand -parent .frame2 -text sddsexpand -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsexpand -options "pipe noWarnings"}
APSButton .sddsexpfit -parent .frame2 -text sddsexpfit -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsexpfit -options "pipe fulloutput columns tolerance verbosity clue guess limits"}
APSButton .sddsfdfilter -parent .frame2 -text sddsfdfilter -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsfdfilter -options "pipe columns exclude clipFrequencies threshold highpass lowpass notch bandpass filterFile cascade newColumns differenceColumns"}
APSButton .sddsfft -parent .frame2 -text sddsfft -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsfft -options "pipe columns exclude window normalize sparse fullOutput psdOutput padwithzeroes truncate suppressaverage noWarnings inverse"}
APSButton .sddsgenericfit -parent .frame2 -text sddsgenericfit -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsgenericfit -options "pipe columns equation target tolerance simplex variable verbosity startFromPrevious"}
APSButton .sddsgfit -parent .frame2 -text sddsgfit -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsgfit -options "pipe columns fitRange fullOutput verbosity stepSize tolerance guesses limits"}
APSButton .sddshist -parent .frame2 -text sddshist -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddshist -options "pipe dataColumn bins sizeOfBins lowerLimit upperLimit filter weightColumn sides normalize statistics verbose"}
APSButton .sddshist2d -parent .frame2 -text sddshist2d -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddshist2d -options "pipe columns weights xParameters yParameters outputName sameScale minimumScale combine normalize smooth verbose"}
APSButton .sddsimageprofiles -parent .frame2 -text sddsimageprofiles -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsimageprofiles -options "pipe profileType columnPrefix method background"}
APSButton .sddsinsideboundaries -parent .frame2 -text sddsinsideboundaries -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsinsideboundaries -options "pipe columns boundary insideColumn keep threads"}
APSButton .sddsinteg -parent .frame2 -text sddsinteg -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsinteg -options "pipe integrate exclude versus mainTemplates errorTemplates method printFinal"}
APSButton .sddsinterp -parent .frame2 -text sddsinterp -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsinterp -options "pipe columns exclude atValues sequence fileValues order printOut belowRange aboveRange"}
APSButton .sddsinterpset -parent .frame2 -text sddsinterpset -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsinterpset -options "pipe data order belowRange aboveRange column atValue"}
APSButton .sddsmatrix2column -parent .frame2 -text sddsmatrix2column -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsmatrix2column -options "pipe rowNameColumn dataColumnName majorOrder"}
APSButton .sddsmatrixmult -parent .frame2 -text sddsmatrixmult -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsmatrixmult -options "pipe commute reuse verbose ascii"}
APSButton .sddsmatrixop -parent .frame2 -text sddsmatrixop -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsmatrixop -options "pipe push add substract swap identity=<number> identity scalarmultiply scalardivide multiply=hadamard divide=hadamard multiply invert columnNames"}
APSButton .sddsminterp -parent .frame2 -text sddsminterp -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsminterp -options "pipe columns order model fileValues verbose ascii"}
APSButton .sddsmselect -parent .frame2 -text sddsmselect -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsmselect -options "pipe match equate invert reuse"}
APSButton .sddsmultihist -parent .frame2 -text sddsmultihist -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsmultihist -options "pipe columns abscissa exclude bins sizeOfBins lowerLimit upperLimit sides"}
APSButton .sddsmxref -parent .frame2 -text sddsmxref -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsmxref -options "pipe ifis ifnot transfer take leave fillIn match equate reuse rename edit nowarnings"}
APSButton .sddsnaff -parent .frame2b -text sddsnaff -size small -packOption "-side top -fill x" \
  -command {setCheckButtons -program sddsnaff -options "pipe column exclude terminateSearch iterateFrequency truncate pair nowarnings"}
APSButton .sddsnormalize -parent .frame2b -text sddsnormalize -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsnormalize -options "pipe columns"}
APSButton .sddsoutlier -parent .frame2b -text sddsoutlier -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsoutlier -options "pipe verbose noWarnings columns excludeColumns stDevLimit absLimit absDeviationLimit chanceLimit passes invert markOnly"}
APSButton .sddspeakfind -parent .frame2b -text sddspeakfind -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddspeakfind -options "pipe column fivePoints threshold exclusionZone changeThreshold"}
APSButton .sddspfit -parent .frame2b -text sddspfit -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddspfit -options "pipe columns terms symmetry orders reviseOrders chebyshev xOffset xFactor sigmas modifySigmas generateSigmas sparse range normalize verbose evaluate fitLabelFormat"}
APSButton .sddsplot -parent .frame2b -text sddsplot -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsplot -options "columnNames parameterNames keep mpl namescan listDevices device output graphic arrowSettings linetypeDefault scales range unsuppressZero sameScale zoom aspectRatio pSpace axes tickSettings subTickSettings grid noScales noBorder xLabel yLabel verticalPrint title topTitle topline filenamesOnTopline labelSize noLabels string dateStamp swap transpose factor offset mode stagger enumeratedScales legend lSpace pintLabel overlay newPanel endPanel layout server tagRequest groupBy separate split omniPresent limit sparse sample presparse filter match"}
APSButton .sddsprintout -parent .frame2b -text sddsprintout -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsprintout -options "pipe columns parameters array fromPage toPage formatDefaults width pageAdvance paginate noTitle title noLabels postPageLines spreadsheet noWarnings"}
APSButton .sddsprocess -parent .frame2b -text sddsprocess -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsprocess -options "pipe filter match test numberTest clip fclip sparse sample rpnDefinitionsFiles rpnExpression scan edit reedit print format system convertUnits define redefine cast process ifis ifnot summarize verbose noWarnings"}
APSButton .sddspseudoinverse -parent .frame2b -text sddspseudoinverse -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddspseudoinverse -options "pipe minimumSingularValueRatio largestSingularValues oldColumnNames root digits newColumnNames symbol ascii weights economy reconstruct vMatrix sFile uMatrix verbose deleteVectors smallestSingularValues multiplyMatrix"}
APSButton .sddsquery -parent .frame2b -text sddsquery -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsquery -options "sddsOutput arraylist associatelist columnlist parameterlist version delimiter appendunits"}
APSButton .sddsregroup -parent .frame2b -text sddsregroup -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsregroup -options "pipe newparameters newcolumns warning verbose"}
APSButton .sddsremoveoffsets -parent .frame2b -text sddsremoveoffsets -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsremoveoffsets -options "pipe columns majorOrder commutationMode fhead removeCommutationOffsetOnly verbose"}
APSButton .sddsrowstats -parent .frame2b -text sddsrowstats -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsrowstats -options "pipe nowarnings mean rms median minimum maximum standardDeviation sigma mad sum drange qrange smallest largest count"}
APSButton .sddsrunstats -parent .frame2b -text sddsrunstats -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsrunstats -options "pipe points window noOverlap partialOk mean minimum maximum standardDeviation sigma sum sample median"}
APSButton .sddssampledist -parent .frame2b -text sddssampledist -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssampledist -options "pipe columns seed samples gaussian uniform poisson verbose"}
APSButton .sddsselect -parent .frame2b -text sddsselect -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsselect -options "pipe match equate invert reuse noWarnings"}
APSButton .sddsseparate -parent .frame2b -text sddsseparate -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsseparate -options "pipe group copy"}
APSButton .sddssequence -parent .frame2b -text sddssequence -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssequence -options "pipe define sequence"}
APSButton .sddsshift -parent .frame2b -text sddsshift -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsshift -options "pipe columns zero shift match circular"}
APSButton .sddsshiftcor -parent .frame2b -text sddsshiftcor -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsshiftcor -options "pipe with scan columns excludeColumns rankOrder stDevOutlier verbose"}
APSButton .sddssinefit -parent .frame2b -text sddssinefit -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssinefit -options "pipe fulloutput columns tolerance limits verbosity guess"}
APSButton .sddsslopes -parent .frame2b -text sddsslopes -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsslopes -options "pipe independentVariable range columns excludeColumns sigma residual ascii verbose"}
APSButton .sddssmooth -parent .frame2b -text sddssmooth -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssmooth -options "pipe columns points passes despike newColumns differenceColumns medianFilter"}
APSButton .sddssort -parent .frame2b -text sddssort -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssort -options "pipe column unique noWarnings"}
APSButton .sddssortcolumn -parent .frame2b -text sddssortcolumn -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssortcolumn -options "pipe sortList decreasing bpmOrder sortWith"}
APSButton .sddssplit -parent .frame2b -text sddssplit -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddssplit -options "pipe binary ascii digits rootname extension nameParameter firstPage lastPage interval"}
APSButton .sddsspotanalysis -parent .frame2b -text sddsspotanalysis -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsspotanalysis -options "pipe ROI spotROIsize imageColumns levels centerOn blankOut sizeLines  singleSpot background despike spotImage"}
APSButton .sddstdrpeeling -parent .frame2b -text sddstdrpeeling -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddstdrpeeling -options "pipe column inputVoltage z0 majorOrder"}
APSButton .sddstimeconvert -parent .frame2b -text sddstimeconvert -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddstimeconvert -options "pipe breakdown epoch"}
APSButton .sddstranspose -parent .frame2b -text sddstranspose -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddstranspose -options "pipe oldColumnNames root digits newColumnNames symbol ascii matchColumn indexColumn noOldColumnNames verbose"}
APSButton .sddsunwrap -parent .frame2b -text sddsunwrap -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsunwrap -options "pipe column threshold modulo"}
APSButton .sddsvslopes -parent .frame2b -text sddsvslopes -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsvslopes -options "pipe independentVariable columns excludeColumns sigma verbose"}
APSButton .sddsxref -parent .frame2b -text sddsxref -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddsxref -options "pipe ifis ifnot transfer take leave fillIn match equate reuse nowarnings rename edit replace"}
APSButton .sddszerofind -parent .frame2b -text sddszerofind -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program sddszerofind -options "pipe zeroesOf columns offset slopeOutput"}
APSButton .tek2sdds -parent .frame2b -text tek2sdds -size small -packOption "-side top -fill x"\
    -command {setCheckButtons -program tek2sdds -options "signalname description mpllabels"}
#citi2sdds elegant2genesis hpif2sdds hpwf2sdds image2sdds lba2sdds mcs2sdds mpl2sdds plaindata2sdds
#raw2sdds sdds2mpl sdds2plaindata sddsarray2column sddsbaseline sddscliptails sddsconvolve sddsdistest 
#sddsendian sddseventhist sddsexpand 
#sddsgenericfit sddsimageprofiles sddsmatrixmult sddsminterp sddsmselect sddsmxref sddsnormalize sddsrunstats 
#sddsshift sddsshiftcor sddssinefit sddsspotanalysis tek2sdds

set testProgramName ""

APSLabeledEntry .testProgram -parent .frame5 -label "Program location:" \
    -textVariable testProgramName -width 63 -packOption "-side left"
APSButton .getTestProgram -parent .frame5 -text F -packOption "-side right" \
    -command {set testProgramNameTemp [APSFileSelectDialog [APSUniqueName .]]; if {[string compare "" $testProgramNameTemp]!=0} {set testProgramName $testProgramNameTemp}}

set compareType exact
set tolerance 1.0e-15
set precision 10
set diffOption ""
  
APSFrame .compare -parent .frame4 -packOption "-expand true"
APSRadioButtonFrame .exact -parent .frame4.compare.frame \
    -buttonList "exact tolerance precision" -orientation horizontal \
    -variable compareType -valueList {exact tolerance precision} -label "Comparison type:" \
    -commandList { "setCompareType -type exact" "setCompareType -type tolerance" "setCompareType -type precision" } \
    -contextHelp "select comparison rule; for exact compare, two data are considered to be the same only if there equal to each other."
APSLabeledEntry .tol -parent .frame4.compare.frame -label "Compare tolerance:" -textVariable tolerance  -width 10 -packOption "-side left" \
    -contextHelp "Two data are considered to be the same if their absolute difference is smaller than the tolerance."
APSLabeledEntry .precision -parent .frame4.compare.frame -label "Compare precision:" -width 10  -packOption "-side left" \
    -textVariable precision -contextHelp "Two data are considered to be same if their first <precision> digits are the same -- relative comparison."
APSDisableWidget .frame4.compare.frame.tol; 
APSDisableWidget .frame4.compare.frame.precision;
   
APSButton .startTest -parent .frame4 -text "Test selected program" -command {testProgram} \
          -packOption "-side left"

APSButton .startTestAll -parent .frame4 -text "Test all programs" -command {testAllPrograms}

proc setCompareType {args} {
    global diffOption tolerance
    set diffOption ""
    set type ""
    APSStrictParseArguments { type }
    switch $type {
        exact {
            APSDisableWidget .frame4.compare.frame.tol; 
            APSDisableWidget .frame4.compare.frame.precision;
            set diffOption "-exact"
       }
        tolerance {
            APSEnableWidget .frame4.compare.frame.tol; 
            APSDisableWidget .frame4.compare.frame.precision; 
            set diffOption "-tol=\$tolerance"
        }
        precision {
            APSDisableWidget .frame4.compare.frame.tol; 
            APSEnableWidget  .frame4.compare.frame.precision; 
            set diffOption -precision=\$precision
        }
    }    	   	   
    
}    

proc setCheckButtons {args} {
    set options none
    set program none
    APSStrictParseArguments {program options}
    global buttonList buttonVar testProgramName
    set buttonList $options
    set buttonVar ""
    set testProgramName [exec which $program]
    global tcl_platform
    if {$tcl_platform(platform) == "windows"} {
        append testProgramName ".exe"
        set testProgramName [string range $testProgramName 1 end]
        set testProgramName [string replace $testProgramName 1 1 ":/"]
        #	set testProgramName [join [split $testProgramName] "\\ "]
    }
    foreach button $buttonList {
        append buttonVar "${button}_$program "
    }
    
    destroy .frame3.checkButtonFrame
    foreach button $buttonVar {
        global $button
        if {![info exists $button]} {
            set $button 1
        }
    }
   
    APSCheckButtonFrame .checkButtonFrame -parent .frame3 -buttonList $buttonList \
        -variableList $buttonVar -allNone 1 -label $program -limitPerRow 20 -packOption "-side left"
    update
}

proc testProgram {args} {
    set program none
    APSStrictParseArguments {program}
    global testProgramName status finalResults
    set finalResults "" 
    if {$program=="none"} {
        if {[catch {.frame3.checkButtonFrame.frame cget -text} program]} {
            APSSetVarAndUpdate status "No Program selected"
            return
        }
    }
    if {![file exists $testProgramName]} {
	APSSetVarAndUpdate status "$testProgramName Program does not exist"
	return
    }
    APSSetVarAndUpdate status "Testing $program using $testProgramName"
    global tcl_platform
    if {$tcl_platform(platform) == "windows"} {
      global env
      set outFile [file join $env(TEMP) [APSTmpString]]
    } else {
      set outFile /tmp/[APSTmpString]
    }
    APSAddToTempFileList $outFile
    global tcl_platform env
    if {$tcl_platform(platform) == "windows"} {
        set passedValue [test_$program -testProgramName $testProgramName -inDir d:/sddsTests/ -outFile $outFile]
    } else {
        set passedValue [test_$program -testProgramName $testProgramName -inDir /home/oxygen/OAG/sddsTests/ -outFile $outFile]
    }
    if {$program <= "sddscontour"} {
	set frameName .frame1
    } elseif {$program <= "sddsmxref"} {
	set frameName .frame2
    } else {
	set frameName .frame2b
    }
    if {$passedValue} {
	if {[string compare $status "Testing for this program is not available yet."]==0} {
	    ${frameName}.${program}.button configure -background yellow
	} else {
	    APSSetVarAndUpdate status "$program Passed"
	    ${frameName}.${program}.button configure -background green
	}
    } else {
	APSSetVarAndUpdate status "$program Failed"
	${frameName}.${program}.button configure -background red
	destroy .${program}Results
	toplevel .${program}Results
	APSScrolledText .text \
	    -parent .${program}Results \
	    -width 80 \
	    -name $program
	.${program}Results.text.text insert end $finalResults
	pack [frame .${program}Results.frame] \
	    -fill x
	pack [button .${program}Results.frame.ok \
		  -text "         OK          " \
		  -command "destroy .${program}Results"] \
	    -side left \
	    -fill x \
	    -expand true
	global replacement
	
	if { [ info exists replacement(old) ] && [ info exists replacement(new) ] } {
            pack [button .${program}Results.frame.update \
                    -text "Replace Standard File" \
                    -command "ReplaceFile -old $replacement(old) -new $replacement(new)"] \
              -side right \
              -fill x \
              -expand true
        }
    }
    set fileList [glob -nocomplain ${outFile}*]
    APSAddToTmpFileList -ID sddsTest -fileList $fileList
}

proc ReplaceFile {args} {
    APSStrictParseArguments {old new}
    global env tcl_platform
    global replacement
    if {($env(USER) != "oag") && ($tcl_platform(platform) != "windows") && ($tcl_platform(os) != "Linux")} {
	APSSetVarAndUpdate status "You must be logged in as oag to replace standard files"
	return
    }
    if [catch {file copy -force -- $new $old} results] {
	APSSetVarAndUpdate status $results
	return
    }
    if {($tcl_platform(platform) != "windows")} {
	catch {exec chmod a+w $old}
    }
    APSSetVarAndUpdate status "File copied"
    unset replacement(new) 
}

proc testAllPrograms {} {
    #
    # 
    # 
    # 
    #  
    set names "citi2sdds csv2sdds editstring elegant2genesis hpif2sdds hpwf2sdds image2sdds lba2sdds mcs2sdds mpl2sdds plaindata2sdds raw2sdds sdds2dinterpolate sdds2math sdds2mpl sdds2plaindata sdds2spreadsheet sdds2stream sdds2tiff sddsarray2column sddsbaseline sddsbinarystring sddsbreak sddscast sddschanges sddscheck sddscliptails sddscollapse sddscollect sddscombine sddscongen sddscontour"
    foreach name $names {
        eval [.frame1.${name}.button cget -command]
        testProgram -program [.frame3.checkButtonFrame.frame cget -text]
    }
    set names "sddsconvert sddsconvolve sddscorrelate sddsderef sddsderiv sddsdiff sddsdigfilter sddsdistest sddsduplicate sddsendian sddsenvelope sddseventhist sddsexpand sddsexpfit sddsfdfilter sddsfft sddsgenericfit sddsgfit sddshist sddshist2d sddsimageprofiles sddsinsideboundaries sddsinteg sddsinterp sddsinterpset sddsmatrixop sddsmatrix2column sddsmatrixmult sddsminterp sddsmselect sddsmultihist sddsmxref "
    foreach name $names {
        eval [.frame2.${name}.button cget -command]
        testProgram -program [.frame3.checkButtonFrame.frame cget -text]
    }
    set names "sddsnaff sddsnormalize sddsoutlier sddspeakfind sddspfit sddsplot sddsprintout sddsprocess sddspseudoinverse sddsquery sddsregroup sddsremoveoffsets sddsrowstats sddsrunstats sddsselect sddsseparate sddssequence sddsshift sddsshiftcor sddssinefit sddsslopes sddssmooth sddssort sddssortcolumn sddssplit sddsspotanalysis sddstdrpeeling sddstimeconvert sddstranspose sddsunwrap sddsvslopes sddsxref sddszerofind tek2sdds"
    foreach name $names {
        eval [.frame2b.${name}.button cget -command]
        testProgram -program [.frame3.checkButtonFrame.frame cget -text]
    }
}
 
proc compareOutput {args} {
    set absolute 0
    APSStrictParseArguments {testProgramName execute standardFile testFile absolute}
    global finalResults replacement diffOption tolerance precision compareType
    APSAddToTempFileList ${testFile}2 ${testFile}3
    
    setCompareType -type $compareType
    if $absolute {
        set extraOption -absolute
    } else {
        set extraOption ""
    }
    if [catch {eval exec sddsdiff $standardFile $testFile $diffOption $extraOption} results] {
        append finalResults "$testProgramName\n\n$execute\n\n$standardFile differs from $testFile\n\n$results\n"
        set replacement(old) $standardFile
        set replacement(new) $testFile
    } else {
        upvar valid x
        set x 1
    }
    if {0} {
    foreach file {standard test} {
        set Parameters [lsort [exec sddsquery [set ${file}File] -parameterlist]]
        set Arrays [lsort [exec sddsquery [set ${file}File] -arraylist]]
        set Columns [lsort [exec sddsquery [set ${file}File] -columnlist]]
        set ${file}Parameters [join $Parameters ","]
        set ${file}Arrays [join $Arrays ","]
            set ${file}Columns [join $Columns ","]
    }
    if [catch "eval exec sddsprintout $standardFile ${testFile}2 \
		   {-parameters=($standardParameters)} {-arrays=($standardArrays)} \
		   {-columns=($standardColumns)} -noTitle -nowarn;exec sddsprintout $testFile \
		   ${testFile}3 {-parameters=($testParameters)} {-arrays=($testArrays)} \
		   {-columns=($testColumns)} -noTitle -nowarn;exec tcomp ${testFile}2 ${testFile}3" results] {
        append finalResults "$testProgramName\n\n$execute\n\n$standardFile differs from $testFile\n\n$results\n"
        set replacement(old) $standardFile
        set replacement(new) $testFile
    } else {
        upvar valid x
        set x 1
    }
    }
}

proc compareOutputTitle {args} {
    APSStrictParseArguments {testProgramName execute standardFile testFile}
    global finalResults replacement
    APSAddToTempFileList ${testFile}2 ${testFile}3 ${testFile}.title
    if [catch {eval exec cp $standardFile ${testFile}.title
        eval exec sddsquery  ${testFile}.title > ${testFile}2 
        eval exec cp $testFile ${testFile}.title
        eval exec sddsquery ${testFile}.title > ${testFile}3
        eval exec tcomp ${testFile}2 ${testFile}3 } results] {
        append finalResults "$testProgramName\n\n$execute\n\n$standardFile differs from $testFile\n\n$results\n"
        set replacement(old) $standardFile
        set replacement(new) $testFile
    } else {
        upvar valid x
        set x 1
    }
}
proc optionsPassed {args} {
    APSStrictParseArguments {pass}
    upvar 2 program name
    foreach option $pass {
	global ${option}_$name
	set ${option}_$name 0
    }
    update
}

proc test_csv2sdds {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}csv2sdds.input $outFile -asciiOutput -spanLines -schFile=${inDir}csv2sdds.sch"
    if [catch {eval exec $execute} results] {
        append finalResults "csv2sdds\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}csv2sdds.output1 -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {asciiOutput schFile spanLines}
	    set execute "{$testProgramName} ${inDir}csv2sdds.input $outFile -asciiOutput -delimiters=start=\#,end=\# -separator=& -columnData=name=column1,type=double -columnData=name=column2,type=string -columnData=name=column3,type=string -columnData=name=column4,type=double -columnData=name=column5,type=string"
	    if [catch {eval exec $execute} results] {
		append finalResults "csv2sdds\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}csv2sdds.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {delimiters separator columnData}
		    set execute "{$testProgramName} ${inDir}csv2sdds.input -pipe=out -asciiOutput -maxRows=4 -schFile=${inDir}csv2sdds.sch | sddsprocess -pipe=in $outFile"
		    if [catch {eval exec $execute} results] {
			append finalResults "csv2sdds\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}csv2sdds.output1 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {pipe maxRows}
			    set returnValue 1
			} 
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sdds2math {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sdds2math.input -pipe=out | {$testProgramName} -pipe=in $outFile -comments {-format=<%g>}"
    if [catch {eval exec $execute} results] {
	append finalResults "sdds2math\n$execute\n$results\n"
    } else {
	if [catch {exec tcomp ${inDir}sdds2math.output $outFile} results] {
	    append finalResults "sdds2math\n$execute\n$results\n"
	} else {
	    optionsPassed -pass {pipe comments format}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sdds2spreadsheet {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sdds2spreadsheet.input -pipe=out | {$testProgramName} -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sdds2spreadsheet\n$execute\n$results\n"
    } else {
	if [catch {exec tcomp ${inDir}sdds2spreadsheet.output $outFile} results] {
	    append finalResults "sdds2spreadsheet\n$execute\n$results\n"
	} else {
	    optionsPassed -pass {pipe}
	    set execute "{$testProgramName} ${inDir}sdds2spreadsheet.input $outFile {-delimiter=& }"
	    if [catch {eval exec $execute} results] {
		append finalResults "sdds2spreadsheet\n$execute\n$results\n"
	    } else {
		if [catch {exec tcomp ${inDir}sdds2spreadsheet.output2 $outFile} results] {
		    append finalResults "sdds2spreadsheet\n$execute\n$results\n"
		} else {
		    optionsPassed -pass {delimiter}
		    set returnValue 1
		}
	    }
	}
    }
    return $returnValue
}

proc test_sdds2stream {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sdds2stream.input -pipe=out | {$testProgramName} -pipe=in -columns=z,number > $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sdds2stream\n$execute\n$results\n"
    } else {
	if [catch {exec tcomp ${inDir}sdds2stream.output $outFile} results] {
	    append finalResults "sdds2stream\n$execute\n$results\n"
	} else {
	    optionsPassed -pass {pipe columns}
	    set execute "{$testProgramName} ${inDir}sdds2stream.input -parameters=Filename,time > $outFile"
	    if [catch {eval exec $execute} results] {
		append finalResults "sdds2stream\n$execute\n$results\n"
	    } else {
		if [catch {exec tcomp ${inDir}sdds2stream.output2 $outFile} results] {
		    append finalResults "sdds2stream\n$execute\n$results\n"
		} else {
		    optionsPassed -pass {parameters}
		    set execute "{$testProgramName} ${inDir}sdds2stream.input -column=Braw,I,string1 -rows -page=3 {-delimiter=& } -noquotes -filenames > $outFile"
		    if [catch {eval exec $execute} results] {
			append finalResults "sdds2stream\n$execute\n$results\n"
		    } else {
			if [catch {exec tcomp ${inDir}sdds2stream.output3 $outFile} results] {
			    append finalResults "sdds2stream\n$execute\n$results\n"
			} else {
			    optionsPassed -pass {rows page delimiter noquotes filenames}
			    set returnValue 1
			}
		    }		    
		}
	    }
	}
    }
    return $returnValue
}

proc test_sdds2tiff {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sdds2tiff.input | {$testProgramName} -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sdds2tiff\n$execute\n$results\n"
    } else {
        set valid 0
        if [catch {exec diff ${inDir}sdds2tiff.output1.0001  ${outFile}.0001} results] {
            append finalResults "sdds2tiff\n$execute\n$results\n"
            set replacement(old) ${inDir}sdds2tiff.output1.0001
            set replacement(new) ${outFile}.0001
        } else {
            set valid 1
        }
        if {$valid} {
            optionsPassed -pass {pipe}
            set execute "sddsprocess -pipe=out ${inDir}sdds2tiff.input | {$testProgramName} -pipe=in $outFile -maxContrast"
            if [ catch { eval exec $execute } results ] { 
                append finalResults "sdds2tiff\n$execute\n$results\n"
            } else {
                set valid 0
                if [catch {exec diff ${inDir}sdds2tiff.output2.0001  ${outFile}.0001} results] {
                    append finalResults "sdds2tiff\n$execute\n$results\n"
                    set replacement(old) ${inDir}sdds2tiff.output2.0001
                    set replacement(new) ${outFile}.0001
                } else {
                    set valid 1
                }
                if {$valid} {
                    optionsPassed -pass {maxcontrast}
                    set execute "sddsprocess -pipe=out ${inDir}sdds2tiff.input | {$testProgramName} -pipe=in $outFile -columnPrefix=Line"
                    if [ catch { eval exec $execute } results ] { 
                        append finalResults "sdds2tiff\n$execute\n$results\n"
                    } else {
                        set valid 0
                        if [catch {exec diff ${inDir}sdds2tiff.output3.0001  ${outFile}.0001} results] {
                            append finalResults "sdds2tiff\n$execute\n$results\n"
                            set replacement(old) ${inDir}sdds2tiff.output3.0001
                            set replacement(new) ${outFile}.0001
                        } else {
                            set valid 1
                        }
                        if {$valid} {
                            optionsPassed -pass {columnPrefix}
                            set execute "sddsprocess -pipe=out ${inDir}sdds2tiff.input | {$testProgramName} -pipe=in $outFile -16bit"
                            if [ catch { eval exec $execute } results ] { 
                                append finalResults "sdds2tiff\n$execute\n$results\n"
                            } else {
                                set valid 0
                                if [catch {exec diff ${inDir}sdds2tiff.output4.0001  ${outFile}.0001} results] {
                                    append finalResults "sdds2tiff\n$execute\n$results\n"
                                    set replacement(old) ${inDir}sdds2tiff.output4.0001
                                    set replacement(new) ${outFile}.0001
                                } else {
                                    set valid 1
                                }
                                if {$valid} {
                                    optionsPassed -pass {16bit}
                                    set returnValue 1
                                }
                            }   	       	 	      		 

                        }
                    }   	       	 	      		 

                }
            }   	       	 	      		 

        }
    }   	       	 	      		 
    return $returnValue
}

proc test_sddsbreak {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsbreak.input -pipe=out | {$testProgramName} -pipe=in $outFile -rowLimit=5"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsbreak\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsbreak.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe rowLimit}
	    set execute "{$testProgramName} ${inDir}sddsbreak.input $outFile -gapIn=z,amount=15"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsbreak\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsbreak.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {gapIn}
		    set execute "{$testProgramName} ${inDir}sddsbreak.input $outFile -changeOf=Bcmp"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddsbreak\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddsbreak.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {changeOf}
			    set execute "{$testProgramName} ${inDir}sddsbreak.input $outFile -increaseOf=Braw"
			    if [catch {eval exec $execute} results] {
				append finalResults "sddsbreak\n$execute\n$results\n"
			    } else {
				set valid 0
				compareOutput -testProgramName $testProgramName -execute $execute \
				    -standardFile ${inDir}sddsbreak.output4 -testFile $outFile
				if {$valid} {
				    optionsPassed -pass {increaseOf}
				    set execute "{$testProgramName} ${inDir}sddsbreak.input $outFile -decreaseOf=Braw"
				    if [catch {eval exec $execute} results] {
					append finalResults "sddsbreak\n$execute\n$results\n"
				    } else {
					set valid 0
					compareOutput -testProgramName $testProgramName -execute $execute \
					    -standardFile ${inDir}sddsbreak.output5 -testFile $outFile
					if {$valid} {
					    optionsPassed -pass {decreaseOf}
					    set returnValue 1
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddscast {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddscast.input -pipe=out -cast=column,G1Short,double,short -cast=column,G1Long,double,long -cast=column,G1Float,double,float | sddsprocess -pipe  \"-process=G1*,ave,%sAve\" \"-define=col,G1LongMinusLong,G1Short G1Long -\" \"-process=G1LongMinusLong,max,G1LongMinusLongMax\" \"-define=col,G1FloatMinusDouble,G1Float G1 -\" \"-process=G1FloatMinusDouble,max,G1FloatMinusDoubleMax\" \"-define=col,G1LongMinusDouble,G1Long G1 -\"  \"-process=G1LongMinusDouble,max,G1LongMinusDoubleMax\" | sddscollapse -pipe | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddscast\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddscast.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe cast}
            set returnValue 1
        }
    }
    return $returnValue
}
proc test_sddschanges {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsbreak.input -pipe=out | {$testProgramName} -pipe -copy=Bcmp,z -changesIn=number,I | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddschanges\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddschanges.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe copy changesIn}
	    set execute "{$testProgramName} ${inDir}sddsbreak.input -baseline=${inDir}sddschanges.baseline $outFile -copy=Bcmp,z -changesIn=number,I"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddschanges\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddschanges.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {baseline}
		    set returnValue 1
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddscheck {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddscheck.input"
    if [catch {eval exec $execute} results] {
	append finalResults "sddscheck\n$execute\n$results\n"
    } else {
	if {[string compare $results corrupted]!=0} {
	    append finalResults "sddscheck\n$execute\n$results\n"
	} else {
	    set execute "{$testProgramName} ${inDir}sddscheck.input2"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddscheck\n$execute\n$results\n"
	    } else {
		if {[string compare $results ok]!=0} {
		    append finalResults "sddscheck\n$execute\n$results\n"
		} else {
		    set execute "{$testProgramName} ${inDir}sddscheck.input3"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddscheck\n$execute\n$results\n"
		    } else {
			if {[string compare $results corrupted]!=0} {
			    append finalResults "sddscheck\n$execute\n$results\n"
			} else {
			    set execute "{$testProgramName} ${inDir}sddscheck.input4"
			    if [catch {eval exec $execute} results] {
				append finalResults "sddscheck\n$execute\n$results\n"
			    } else {
				if {[string compare $results badHeader]!=0} {
				    append finalResults "sddscheck\n$execute\n$results\n"
				} else {
				    set execute "{$testProgramName} ${inDir}sddscheck.input4 -printErrors"
				    if [catch {eval exec $execute} results] {
					optionsPassed -pass {printErrors}
					set returnValue 1
				    } else {
					append finalResults "sddscheck\n$execute\n$results\n"
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddscollapse {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddscollapse.input $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddscollapse\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddscollapse.output -testFile $outFile
	if {$valid} {
	    set execute "sddsprocess ${inDir}sddscollapse.input -pipe=out | {$testProgramName} -pipe=in $outFile"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddscollapse\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddscollapse.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {pipe}
		    set returnValue 1
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddscollect {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddscollect.input -pipe=out | {$testProgramName} -pipe=in $outFile -collect=suffix=float1 -collect=prefix=long,column=longg"
    if [catch {eval exec $execute} results] {
        append finalResults "sddscollect\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddscollect.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe collect}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddscombine {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddscombine.input ${inDir}sddscombine.input2 $outFile -overWrite"
    if [catch {eval exec $execute} results] {
        append finalResults "sddscombine\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddscombine.output -testFile $outFile
	if {$valid} {
	    set execute "{$testProgramName} ${inDir}sddscombine.input ${inDir}sddscombine.input2 $outFile -overWrite -merge" 
	    if [catch {eval exec $execute} results] {
		append finalResults "sddscombine\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddscombine.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {overWrite}
		    set execute "{$testProgramName} ${inDir}sddscombine.input ${inDir}sddscombine.input2 -pipe=out -merge -retain=column,B* | sddsprocess -pipe=in $outFile"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddscombine\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddscombine.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {pipe retain merge}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddscongen {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} $outFile -xrange=-1,1,21 -yrange=-1,1,21 {-zequation=x x * y y * + 4 * pi * sin}"
    if [catch {eval exec $execute} results] {
        append finalResults "sddscongen\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddscongen.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {xrange yrange zequation}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddscontour {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults  
    global replacement
    set execute "{$testProgramName} ${inDir}sddscontour.input -quantity=z -shade -xLabel=Pressure -yLabel=Speed -title=ContourPlot -topline=2-DFunction -verbosity=0 -device=png -equalAspect -mapshade=1,0 -layout=2,2 -swapxy -output=$outFile"
    if [ catch {eval exec $execute } results ] {
        append finalResults "sddscontour\n$execute\n$results\n"
    } else {
        if [catch {exec diff ${inDir}sddscontour.output1  $outFile} results] {
            append finalResults "sddscontour\n$execute\n$results\n"
            eval exec display $outFile &
            eval exec display ${inDir}sddscontour.output1 &
            set replacement(old) ${inDir}sddscontour.output1
            set replacement(new) $outFile
        } else {
            set execute "{$testProgramName} ${inDir}sddscontour.input5 -device=png,onwhite -output=$outFile -shade -title=@ChargeLabel -topline= -layout=2,5"
            if [ catch {eval exec $execute } results ] {
                append finalResults "sddscontour\n$execute\n$results\n"
            } else {
                if [catch {exec diff ${inDir}sddscontour.output7 $outFile} results] {
                    append finalResults "sddscontour\n$execute\n$results\n"
                    eval exec display $outFile &
                    eval exec display ${inDir}sddscontour.output7 &
                    set replacement(old) ${inDir}sddscontour.output7
                    set replacement(new) $outFile 
                } else {
                    optionsPassed -pass { quantity shade xLabel yLabel title topline device verbosity equalAspect swapxy output layout mapshade }
                    set execute "{$testProgramName} ${inDir}sddscontour.input -quantity=z3 -scales=-0.5,0.5,-0.5,0.5 -contours=10 -labelContours=2  -topTitle -interpolate=2,2,floor -noBorder -noScales -device=png -output=$outFile -layout=2,2 "
                    if [ catch { eval exec $execute } results ] {
                        append finalResults "sddscontour\n$execute\n$results\n"
                    } else {
                        if [catch {exec diff ${inDir}sddscontour.output2  $outFile} ] {
                            append finalResults "sddscontour\n$execute\n$results\n"
                            eval exec display $outFile &
                            eval exec display ${inDir}sddscontour.output2 &
                            set replacement(old) ${inDir}sddscontour.output2
                            set replacement(new) $outFile
                        } else {
                            optionsPassed -pass { contours scales topTitle interpolate noBorder noScales labelContours }
                            set execute "{$testProgramName} ${inDir}sddscontour.input2 -columnMatch=Index,z* -shade -noLabels -deltas=normalize -interpolate=2,2 -filter=2,2 -logscale  -ystring=sparse=20,scale=2,edit=%/z/Z/ -device=png -output=$outFile -layout=2,1"
                            if [ catch { eval exec $execute } results ] {
                                append finalResults "sddscontour\n$execute\n$results\n"
                            } else {
                                if [catch {exec diff ${inDir}sddscontour.output3  $outFile} ] {
                                    append finalResults "sddscontour\n$execute\n$results\n"
                                    eval exec display $outFile &
                                    eval exec display ${inDir}sddscontour.output3 &
                                    set replacement(old) ${inDir}sddscontour.output3
                                    set replacement(new) $outFile
                                } else {
                                    optionsPassed -pass { columnMatch  logscale deltas  filter ystrings }
                                    set execute "${testProgramName} ${inDir}sddscontour.input3  -shade -interpolate=2,2,floor -noLabels -thickness=2 -device=png -output=$outFile {-equation=xIndex 10. / yIndex 10. / drmhd} {-rpnExpression=\"${inDir}sddscontour.rpn\\\,s\"  @ } "
                                    if [ catch { eval exec $execute } results ] {
                                        append finalResults "sddscontour\n$execute\n$results\n"
                                    } else {
                                        if [catch {exec diff ${inDir}sddscontour.output4  $outFile} ] {
                                            append finalResults "sddscontour\n$execute\n$results\n"
                                            eval exec display $outFile &
                                            eval exec display ${inDir}sddscontour.output4 &
                                            set replacement(old) ${inDir}sddscontour.output4
                                            set replacement(new) $outFile
                                        } else {
                                            optionsPassed -pass { equation noLabels rpnExpressions thickness } 
                                            set execute "${testProgramName} ${inDir}sddscontour.input3  -shade -interpolate=2,2,floor -device=png -output=$outFile {-equation=xIndex 10. / yIndex 10. / drmhd} -rpnDefinitionsFile=${inDir}sddscontour.rpn "
                                            if [ catch { eval exec $execute } results ] {
                                                append finalResults "sddscontour\n$execute\n$results\n"
                                            } else {
                                                if [ catch { exec diff ${inDir}sddscontour.output5 $outFile} ] {
                                                    append finalResults "sddscontour\n$execute\n$results\n"
                                                    eval exec display $outFile &
                                                    eval exec display ${inDir}sddscontour.output5 &
                                                    set replacement(old) ${inDir}sddscontour.output5
                                                    set replacement(new) $outFile	  
                                                } else {
                                                    optionsPassed -pass { rpnDefinitionsFiles }
                                                    set execute "${testProgramName} ${inDir}sddscontour.input4 -shade -col=ux,Uy* -title=sddscontour.output6 -ylabel=Uy,scale=1 -xlabe=Ux -device=png -output=$outFile -ystrings=sparse=10,edit=%/Uy// -ticksettings=xtime "
                                                    if [ catch {eval exec $execute } results ] {
                                                        append finalResults "sddscontour\n$execute\n$results\n"
                                                    } else {
                                                        if [ catch { exec diff ${inDir}sddscontour.output6 $outFile} ] {
                                                            append finalResults "sddscontour\n$execute\n$results\n"
                                                            eval exec display $outFile &
                                                            eval exec display ${inDir}sddscontour.output6 &
                                                            set replacement(old) ${inDir}sddscontour.output6
                                                            set replacement(new) $outFile	
                                                        } else {    
                                                            optionsPassed -pass { ticksettings }
                                                            set execute "${testProgramName} ${inDir}sddscontour.input6 -shade -column=Index,Ex* -yrange=min=@origin2,max=@max_ext2 -xrange=min=@origin1,max=@max_ext1 -xlabel=x -ylabel=y -shade -device=png -output=$outFile"
                                                            if [ catch {eval exec $execute } results ] {
                                                                append finalResults "sddscontour\n$execute\n$results\n"
                                                            } else {
                                                                if [ catch { exec diff ${inDir}sddscontour.output8 $outFile} ] {
                                                                    append finalResults "sddscontour\n$execute\n$results\n"
                                                                    eval exec display $outFile &
                                                                    eval exec display ${inDir}sddscontour.output8 &
                                                                    set replacement(old) ${inDir}sddscontour.output8
                                                                    set replacement(new) $outFile	
                                                                } else {    
                                                                    optionsPassed -pass { xrange yrange }
                                                                    set returnValue 1
                                                                }
                                                            }
                                                        }
                                                    }		   
                                                }
                                            }	     
                                        }
                                    }   	 
                                }
                            }	
                        }
                    }      
                }
            }   
        }
    }
    return $returnValue 
}

proc test_sddsconvert {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsconvert.input -pipe=out -binary | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsconvert\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsconvert.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe binary ascii}
	    set execute "{$testProgramName} ${inDir}sddsconvert.input -pipe=out -binary -fromPage=2 -delete=columns,B* -rename=parameter,dummy=dum | {$testProgramName} -pipe=in $outFile -ascii -toPage=1 -retain=columns,*n* -description=DText,DContents -linesPerRow=2"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsconvert\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsconvert.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {fromPage toPage delete retain rename description linesPerRow}
		    set execute "{$testProgramName} ${inDir}sddsconvert.input $outFile -ascii -editNames=columns,*,i/insert/"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddsconvert\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddsconvert.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {editNames}
			    set execute "{$testProgramName} ${inDir}sddscheck.input3 $outFile -ascii -editNames=columns,*,i/insert/ -recover"
			    if [catch {eval exec $execute} results] {
				append finalResults "sddsconvert\n$execute\n$results\n"
			    } else {
				set valid 0
				compareOutput -testProgramName $testProgramName -execute $execute \
				    -standardFile ${inDir}sddsconvert.output4 -testFile $outFile
				if {$valid} {
				    set execute "{$testProgramName} ${inDir}sddscheck.input3 $outFile -ascii -editNames=columns,*,i/insert/ -recover=clip"
				    if [catch {eval exec $execute} results] {
					append finalResults "sddsconvert\n$execute\n$results\n"
				    } else {
					set valid 0
					compareOutput -testProgramName $testProgramName -execute $execute \
					    -standardFile ${inDir}sddsconvert.output5 -testFile $outFile
					if {$valid} {
					    optionsPassed -pass {recover}
					    set returnValue 1
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddscorrelate {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddscorrelate.input -pipe=out -columns=*X | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddscorrelate\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddscorrelate.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe columns}
	    set execute "{$testProgramName} ${inDir}sddscorrelate.input $outFile -columns=*X -withOnly=double1X -excludeColumns=double2X,double4X"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddscorrelate\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddscorrelate.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {withOnly excludeColumns}
		    set execute "{$testProgramName} ${inDir}sddscorrelate.input $outFile -columns=*X -stDevOutlier=limit=2,passes=2"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddscorrelate\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddscorrelate.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {stDevOutlier}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddsderef {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsderef.input -pipe=out | {$testProgramName} -pipe=in $outFile -column=AlarmStatus,array=AlarmStatusString,AlarmStatusIndex -column=AlarmSeverity,array=AlarmSeverityString,AlarmSeverityIndex"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsderef\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsderef.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe}
	    set execute "{$testProgramName} ${inDir}sddsderef.input2 $outFile -outOfBounds=delete -column=ControlName,array=ControlNameString,ControlNameIndex -column=AlarmSeverity,array=AlarmSeverityString,AlarmSeverityIndex -column=AlarmStatus,array=AlarmStatusString,AlarmStatusIndex -column=Description,array=DescriptionString,ControlNameIndex"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsderef\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsderef.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {column outOfBounds}
		    set returnValue 1
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddsderiv {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsderiv.input -pipe=out -versus=x -differ=x5,x5Error -differ=x3,%sError {-differ=x\[24\],%sError} -exclude=x3,x5 | sddsprocess -pipe=in $outFile"
   # set execute "sddscombine ${inDir}sddsderiv.input  ${inDir}sddsderiv.input ${inDir}sddsderiv.input -pipe=out | {$testProgramName} -pipe -versus=x  -differ=x5,x5Error -differ=x3,%sError {-differ=x\[24\],%sError} -exclude=x3,x5 | sddsprocess -pipe -delete=parameters,Filename,NumberCombined | sddssplit -pipe=in -interval=3 -rootname=$outFile -extension= "

    if [catch {eval exec $execute} results] {
        append finalResults "sddsderiv\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsderiv.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe differentiate exclude versus}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsdigfilter {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 1
    global finalResults
    set execute "sddsprocess ${inDir}sddsdigfilter.input -pipe=out | {$testProgramName} -pipe=in,out -columns=TimeOfDay,WindSpeed60m -proportional=2 -cascade -lowpass=1,0.5    | sddsprocess -pipe=in $outFile "
    if [ catch { eval exec $execute } results] {
       append finalResults "sddsdigfilter\n$execute\n$results\n"
       return 0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsdigfilter.output1 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {pipe columns proportional cascade lowpass}
       } else {
          return 0
       }	  
    }
    set execute " {$testProgramName}  ${inDir}sddsdigfilter.input -columns=TimeOfDay,WindSpeed60m   -highpass=1,0.5  $outFile "
    if [ catch { eval exec $execute } results] {
       append finalResults "sddsdigfilter\n$execute\n$results\n"
       return 0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsdigfilter.output2 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {highpass}
       } else {
          return 0
       }	  
    }
    set execute " {$testProgramName}  ${inDir}sddsdigfilter.input -columns=TimeOfDay,WindSpeed60m  -digitalfilter=A,1,0,0,1,B,0,0,0,1   $outFile "
    if [ catch { eval exec $execute } results] {
       append finalResults "sddsdigfilter\n$execute\n$results\n"
       return 0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsdigfilter.output3 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {digitalfilter}
       } else {
          return 0
       }	  
    }
    set execute " {$testProgramName}  ${inDir}sddsdigfilter.input -columns=TimeOfDay,WindSpeed60m  -analogfilter=C,.1,0.01,0.5,D,0.01,0.1  $outFile "
    if [ catch { eval exec $execute } results] {
       append finalResults "sddsdigfilter\n$execute\n$results\n"
       return 0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsdigfilter.output4 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {analogfilter}
       } else {
          return 0
       }	  
    }
    set execute " {$testProgramName} ${inDir}sddsdigfilter.input -columns=TimeOfDay,Wind* -analogfilter=${inDir}sddsdigfilter.analog,Ccoeff,Dcoeff  $outFile"
    if [ catch { eval exec $execute } results] {
       append finalResults "sddsdigfilter\n$execute\n$results\n"
       return 0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsdigfilter.output5 -testFile $outFile
       if {!$valid} {
          return 0
       } 	  
    }
    return $returnValue
}    





proc test_sddsenvelope {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsenvelope.input -pipe=out | {$testProgramName} -pipe=in $outFile -copy=Index {-maximum=*} {-minimum=*} {-mean=*} {-rms=*} {-sum=2,*} {-slope=para1,*} {-intercept=para1,*} {-standardDeviation=*}"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsenvelope\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsenvelope.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe copy maximum minimum mean rms sum standardDeviation slope intercept}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsexpfit {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsexpfit.input -pipe=out -fulloutput -columns=x,y,ysigma=sy -tolerance=1e-12 -clue=decay | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsexpfit\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsexpfit.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe fulloutput columns tolerance clue}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsfdfilter {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 1
    global finalResults
    set execute "sddsprocess ${inDir}sddsfdfilter.input1 -pipe=out | {$testProgramName} -pipe -columns=Index,Image* -clipFrequencies=high=4,low=0.2  | sddsprocess -pipe=in $outFile "
    if [ catch { eval exec $execute } results] {
       append finalResults "sddsfdfilter\n$execute\n$results\n"
       return 0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfdfilter.output1 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {pipe columns clipFrequencies}
       } else {
          return 0
       }	  
    }
    set execute "${testProgramName} ${inDir}sddsfdfilter.input1 -columns=Index,Image2.0* -exclude=Image2.0 -threshold=level=0.1,fractional,start=0.1,end=5 -newColumns -differenceColumns $outFile"
     if [ catch { eval exec $execute } results] {
       append finalResults "sddsfdfilter\n$execute\n$results\n"
       return  0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfdfilter.output2 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {exclude threshold newColumns differenceColumns}
       } else {
          return 0
       }	  
    }    
    set execute "${testProgramName} ${inDir}sddsfdfilter.input1 -columns=Index  -lowpass=start=4,end=5 -cascade -highpass=start=0.2,end=0.6  $outFile"
     if [ catch { eval exec $execute } results] {
       append finalResults "sddsfdfilter\n$execute\n$results\n"
       return  0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfdfilter.output3 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {highpass lowpass cascade }
       } else {
          return 0
       }	  
    }        
    set execute "${testProgramName} ${inDir}sddsfdfilter.input2 -columns=Index  -notch=center=0.2,flatwidth=0.2,fullwidth=2.0   $outFile"
     if [ catch { eval exec $execute } results] {
       append finalResults "sddsfdfilter\n$execute\n$results\n"
       return  0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfdfilter.output4 -testFile $outFile
       if {$valid} {
          optionsPassed -pass { notch }
       } else {
          return 0
       }	  
    }        
    set execute "${testProgramName} ${inDir}sddsfdfilter.input2 -columns=Index  -bandpass=center=0.2,flatwidth=0.2,fullwidth=2.0   $outFile"
     if [ catch { eval exec $execute } results] {
       append finalResults "sddsfdfilter\n$execute\n$results\n"
       return  0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfdfilter.output5 -testFile $outFile
       if {$valid} {
          optionsPassed -pass { bandpass }
       } else {
          return 0
       }	  
    }        
    set execute "${testProgramName} ${inDir}sddsfdfilter.input2 -columns=Index  -filterFile=filename=${inDir}sddsfdfilter.filter,frequency=f,magnitude=FFTImage2   $outFile"
     if [ catch { eval exec $execute } results] {
       append finalResults "sddsfdfilter\n$execute\n$results\n"
       return  0
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfdfilter.output6 -testFile $outFile
       if {$valid} {
          optionsPassed -pass { filterFile }
       } else {
          return 0
       }	  
    }     
    
    return $returnValue
    
}


proc test_sddsfft {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsfft.input -pipe=out -columns=x,A* -exclude=t -fullOutput -padwithzeroes -suppressaverage | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsfft\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsfft.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe columns exclude fullOutput padwithzeroes suppressaverage}
	    set execute "{$testProgramName} ${inDir}sddsfft.input2 $outFile -column=Pass,Cx -window=hanning"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsfft\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsfft.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {window}
		    set execute "{$testProgramName} ${inDir}sddsfft.input3 $outFile -col=t,x -psdOutput"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddsfft\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddsfft.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {psdOutput}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    if !$returnValue {
        return 0
    }
    foreach rows {8 9 10 11} {
        set execute "{$testProgramName} ${inDir}sddsfft_${rows}rows.input -pipe=out -col=t,x -fullOutput=folded \
               |  {$testProgramName} -pipe=in -complexInput -fullOutput $outFile -col=f,FFTx -inverse"
        if [catch {eval exec $execute} results] {
            append finalResults "sddsfft\n$execute\n$results\n"
            return 0
        } else {
            set valid 0
            compareOutput  -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfft_${rows}rows.output -testFile $outFile
            if !$valid {
                return 0
            }
        }
        set execute "{$testProgramName} ${inDir}sddsfft_${rows}rows.input -pipe=out -col=t,x -fullOutput=unfolded \
               |  {$testProgramName} -pipe=in -complexInput -fullOutput $outFile -col=f,FFTx -inverse"
        if [catch {eval exec $execute} results] {
            append finalResults "sddsfft\n$execute\n$results\n"
            return 0
        } else {
            set valid 0
            compareOutput  -testProgramName $testProgramName -execute $execute \
              -standardFile ${inDir}sddsfft_${rows}arows.output -testFile $outFile
            if !$valid {
                return 0
            }
        }
    }
    optionsPassed -pass {inverse}
    return 1
}

proc test_sddsgfit {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsgfit.input -pipe=out -fullOutput -columns=x,y,ySigma=sy -limits=evaluations=1000,passes=10 -fitRange=-1,3 | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsgfit\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsgfit.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe fullOutput columns limits fitRange}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddshist {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddshist.input -pipe=out -size=1 -lower=0 -upper=40 -data=n -stat | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddshist\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddshist.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe sizeOfBins lowerLimit upperLimit dataColumn statistics}
	    set execute "{$testProgramName} ${inDir}sddshist.input $outFile -size=1 -lower=0 -upper=40 -data=n -stat -norm"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddshist\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddshist.output2 -testFile $outFile
		if {$valid} {
		    set execute "{$testProgramName} ${inDir}sddshist.input $outFile -size=1 -lower=0 -upper=40 -data=n -stat -norm=area"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddshist\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddshist.output3 -testFile $outFile
			if {$valid} {
			    set execute "{$testProgramName} ${inDir}sddshist.input $outFile -size=1 -lower=0 -upper=40 -data=n -stat -norm=peak"
			    if [catch {eval exec $execute} results] {
				append finalResults "sddshist\n$execute\n$results\n"
			    } else {
				set valid 0
				compareOutput -testProgramName $testProgramName -execute $execute \
				    -standardFile ${inDir}sddshist.output4 -testFile $outFile
				if {$valid} {
				    optionsPassed -pass {normalize}
				    set execute "{$testProgramName} ${inDir}sddshist.input $outFile -lower=0 -upper=40 -data=n -stat -bins=15 -sides"
				    if [catch {eval exec $execute} results] {
					append finalResults "sddshist\n$execute\n$results\n"
				    } else {
					set valid 0
					compareOutput -testProgramName $testProgramName -execute $execute \
					    -standardFile ${inDir}sddshist.output5 -testFile $outFile
					if {$valid} {
					    optionsPassed -pass {bins sides}
					    set returnValue 1
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}


proc test_sddshist2d {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddshist2d.input | {$testProgramName} -pipe -columns=P1P1x,P1P2x -xpar=25,-1.5,-1.0 -ypar=25,-0.8,0 -combine  -weights=P3P1x,average  -smooth=2 -outputName=freq | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results] {
       append finalResults "sddshist2d\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddshist2d.output1 -testFile $outFile
       if {$valid} {
          optionsPassed -pass { pipe columns xParameters yParameters smooth combine weights outputName }
	  set execute "{$testProgramName} ${inDir}sddshist2d.input2 -columns=Pressure -ypar=25,1e-6,1e-5 -smooth=2  -normalize=sum  -sameScale -outputName=freq $outFile"
	  if [ catch { eval exec $execute } results] {
             append finalResults "sddshist2d\n$execute\n$results\n"
          } else {
             set valid 0
             compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddshist2d.output2 -testFile $outFile
             if {$valid} {
	        optionsPassed -pass {normalize sameScale }
		set execute "{$testProgramName} ${inDir}sddshist2d.input3 -columns=dummy,P1P1x -minimumScale=5 $outFile"
		if [ catch { eval exec $execute } results] {
		   append finalResults "sddshist2d\n$execute\n$results\n"
		} else {
		   set valid 0
		   compareOutput -testProgramName $testProgramName -execute $execute \
		          -standardFile ${inDir}sddshist2d.output3 -testFile $outFile
	           if {$valid} {
		      optionsPassed -pass {minimumScale}
		      set returnValue 1
		   }
		}      
             }
	  }   		
       }
    }   	  
    return $returnValue
}


proc test_sddsinteg {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsinteg.input -pipe=out -versus=x -integ=x1 -integ=x3 {-integ=x\[24\]} -exclude=x3,x1 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsinteg\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsinteg.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe versus integrate exclude}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsinterp {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsinterp.input -pipe=out -fileValues=${inDir}sddsinterp.evals,col=x,parallel -col=x,y -order=7 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsinterp\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsinterp.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe fileValues columns order}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsinterpset {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsinterpset.input2 -pipe=out \"-redefine=col,IntegratedStrength,IntegratedStrength 400 *\" | {$testProgramName} -pipe -order=1 -data=file=ExcitationFile,interp=Current,func=IntegratedStrength,col=IntegratedStrength -above=saturate -below=value=999 | sddsconvert -pipe=in -ascii $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsinterpset\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsinterpset.output2 -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {aboveRange}
            set execute "sddsprocess ${inDir}sddsinterpset.input2 -pipe=out \"-redefine=col,IntegratedStrength,IntegratedStrength 0.0001 *\" | {$testProgramName} -pipe -order=1 -data=file=ExcitationFile,interp=Current,func=IntegratedStrength,col=IntegratedStrength -below=value=999 | sddsconvert -pipe=in -ascii $outFile"
            if [catch {eval exec $execute} results] {
                append finalResults "sddsinterpset\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsinterpset.output3 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {belowRange}
                    set execute "{$testProgramName} ${inDir}sddsinterpset.input1 -pipe=out \"-data=fileColumn=ExcitationFile,interpolate=Current,functionOf=IntegratedStrength,column=IS\" -order=3 | sddsconvert -pipe=in $outFile -ascii"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddsinterpset\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddsinterpset.output1 -testFile $outFile
                        if {$valid} {
                            optionsPassed -pass {column}
                            set execute "{$testProgramName} ${inDir}sddsinterpset.input1 -pipe=out \"-data=fileColumn=ExcitationFile,interpolate=Current,functionOf=IntegratedStrength,atValue=0.01\" -order=3 | sddsconvert -pipe=in $outFile -ascii"
                            if [catch {eval exec $execute} results] {
                                append finalResults "sddsinterpset\n$execute\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddsinterpset.output4 -testFile $outFile
                                if {$valid} {
                                    set execute "sddsprocess ${inDir}sddsinterpset.input3 -pipe=out \"-redefine=col,IntegratedStrength,IntegratedStrength\"  | {$testProgramName} -pipe=in -order=1 -data=file=ExcitationFile,interp=Current,func=IntegratedStrength,col=IntegratedStrength -data=file=ExcitationFile,interp=B,func=IntegratedStrength,col=IntegratedStrength -above=saturate -below=value=999 $outFile"
                                    if [catch {eval exec $execute} results] {
                                        append finalResults "sddsinterpset\n$execute\n$results\n"
                                    } else {
                                        set valid 0
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                          -standardFile ${inDir}sddsinterpset.output5 -testFile $outFile
                                        if $valid {
                                            optionsPassed -pass {atValue data pipe order}
                                            set returnValue 1
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return $returnValue
}
proc test_sddsmultihist {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsmultihist.input -pipe=out -columns=G1 -abscissa=G | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmultihist\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsmultihist.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe columns abscissa}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsoutlier {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x,y,xp,yp -stdev=2 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsoutlier\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsoutlier.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe columns stDevLimit}
            set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -excludecol=*p -absDev=0.1 | sddsconvert -pipe=in $outFile -ascii"
            if [catch {eval exec $execute} results] {
                append finalResults "sddsoutlier\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsoutlier.output1 -testFile $outFile
                if $valid {
                    optionsPassed -pass {excludeColumns}
                    set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -absDev=0.5,neighbor=3 | sddsconvert -pipe=in $outFile -ascii"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddsoutlier\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddsoutlier.output2 -testFile $outFile
                        if $valid {
                            optionsPassed -pass {absDeviationLimit}
                            set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -abslimit=0.5 | sddsconvert -pipe=in $outFile -ascii"
                            if [catch {eval exec $execute} result] {
                                append finalResults "sddsoutlier\n$execute\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddsoutlier.output3 -testFile $outFile
                                if $valid {
                                    optionsPassed -pass {absLimit}
                                    set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out  -col=x,y -maximumlimit=0.1 -minimumlimit=-0.001 | sddsconvert -pipe=in $outFile -ascii"
                                    if [catch {eval exec $execute} results] {
                                        append finalResults "sddsoutlier\n$execute\n$results\n"
                                    }  else {
                                        set valid 0
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                          -standardFile ${inDir}sddsoutlier.output4 -testFile $outFile
                                        if $valid {
                                            optionsPassed -pass {maximumLimit minimumLimit}
                                            set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x,y -chanceLimit=0.5 | sddsconvert -pipe=in -ascii $outFile"
                                            if [catch {eval exec $execute} results] {
                                                append finalResults "sddsoutlier\n$execute\n$results\n"
                                            } else {
                                                set valid 0
                                                compareOutput -testProgramName $testProgramName -execute $execute \
                                                  -standardFile ${inDir}sddsoutlier.output5 -testFile $outFile
                                                if $valid {
                                                    optionsPassed -pass {chanceLimit}
                                                    set execute  "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x -std=0.01 -pass=2 -invert | sddsconvert -pipe=in -ascii $outFile"
                                                    if [catch {eval exec $execute} results] {
                                                        append finalResults "sddsoutlier\n$execute\n$results\n"
                                                    } else {
                                                        set valid 0
                                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                                          -standardFile ${inDir}sddsoutlier.output6 -testFile $outFile
                                                        if $valid {
                                                            optionsPassed -pass {invert passes}
                                                            set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out  -absLimit=0.01 -col=x*,y* -markOnly | sddsconvert -pipe=in -ascii $outFile"
                                                            if [catch {eval exec $execute} results] {
                                                                append finalResults "sddsoutlier\n$execute\n$results\n"
                                                            } else {
                                                                set valid 0
                                                                compareOutput -testProgramName $testProgramName -execute $execute \
                                                                  -standardFile ${inDir}sddsoutlier.output7 -testFile $outFile
                                                                if $valid {
                                                                    optionsPassed -pass {markOnly}
                                                                    set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -absDev=0.01 -replaceonly=lastvalue | sddsconvert -pipe=in -ascii $outFile"
                                                                    if [catch {eval exec $execute} results] {
                                                                        append finalResults "sddsoutlier\n$execute\n$results\n"
                                                                    } else {
                                                                        set valid 0
                                                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                                                          -standardFile ${inDir}sddsoutlier.output8 -testFile $outFile
                                                                        if $valid {
                                                                            set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -absDev=0.01 -replaceonly=nextvalue | sddsconvert -pipe=in -ascii $outFile"
                                                                            if [catch {eval exec $execute} results] {
                                                                                append finalResults "sddsoutlier\n$execute\n$results\n"
                                                                            } else {
                                                                                set valid 0
                                                                                compareOutput -testProgramName $testProgramName -execute $execute \
                                                                                  -standardFile ${inDir}sddsoutlier.output9 -testFile $outFile
                                                                                if $valid {
                                                                                    set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -absDev=0.01 -replaceonly=interp | sddsconvert -pipe=in -ascii $outFile"
                                                                                    if [catch {eval exec $execute} results] {
                                                                                        append finalResults "sddsoutlier\n$execute\n$results\n"
                                                                                    } else {
                                                                                        set valid 0
                                                                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                                                                          -standardFile ${inDir}sddsoutlier.output10 -testFile $outFile
                                                                                        if $valid {
                                                                                             set execute "${testProgramName} ${inDir}sddsoutlier.input -pipe=out -col=x*,y* -absDev=0.01 -replaceonly=value=0.1 | sddsconvert -pipe=in -ascii $outFile"
                                                                                            if [catch {eval exec $execute} results] {
                                                                                                append finalResults "sddsoutlier\n$execute\n$results\n"
                                                                                            } else {
                                                                                                set valid 0
                                                                                                compareOutput -testProgramName $testProgramName -execute $execute \
                                                                                                  -standardFile ${inDir}sddsoutlier.output11 -testFile $outFile
                                                                                                if $valid {
                                                                                                    optionsPassed -pass {replaceOnly}
                                                                                                    set returnValue 1
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
	}
    }
    
    return $returnValue
}

proc test_sddspeakfind {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults 
    set execute "sddsprocess ${inDir}sddspeakfind.input -pipe=out | {$testProgramName} -pipe=in $outFile -column=RN1"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspeakfind\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddspeakfind.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe column}
	    set execute "{$testProgramName} ${inDir}sddspeakfind.input $outFile -column=RN1 -fivePoints"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddspeakfind\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddspeakfind.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {fivePoints}
		    set execute "{$testProgramName} ${inDir}sddspeakfind.input $outFile -column=RN1 -threshold=.7"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddspeakfind\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddspeakfind.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {threshold}
			    set execute "{$testProgramName} ${inDir}sddspeakfind.input $outFile -column=RN1 -exclusionZone=.5"
			    if [catch {eval exec $execute} results] {
				append finalResults "sddspeakfind\n$execute\n$results\n"
			    } else {
				set valid 0
				compareOutput -testProgramName $testProgramName -execute $execute \
				    -standardFile ${inDir}sddspeakfind.output4 -testFile $outFile
				if {$valid} {
				    optionsPassed -pass {exclusionZone}
				    set execute "{$testProgramName} ${inDir}sddspeakfind.input $outFile -column=RN1 -changeThreshold=.7"
				    if [catch {eval exec $execute} results] {
					append finalResults "sddspeakfind\n$execute\n$results\n"
				    } else {
					set valid 0
					compareOutput -testProgramName $testProgramName -execute $execute \
					    -standardFile ${inDir}sddspeakfind.output5 -testFile $outFile
					if {$valid} {
					    optionsPassed -pass {changeThreshold}
					    set returnValue 1
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddspfit {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    APSAddToTempFileList ${outFile}4 ${outFile}5
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddspfit.input -pipe=out -columns=MALIN.DX,Tune -terms=4 -symmetry=even -fitLabelFormat=%.3g -evaluate=${outFile}4,number=8 | sddsconvert -pipe=in $outFile -ascii"
    set execute2 "sddsconvert ${outFile}4 ${outFile}5 -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspfit\n$execute\n$results\n"
    } else {
        if [catch {eval exec $execute2} results] {
            append finalResults "sddspfit\n$execute\n$execute2\n$results\n"
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -execute $execute \
                -standardFile ${inDir}sddspfit.output -testFile $outFile
            if {$valid} {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                    -standardFile ${inDir}sddspfit.output2 -testFile ${outFile}5
                if {$valid} {
                    optionsPassed -pass {pipe columns terms symmetry fitLabelFormat evaluate}
                    set execute "{$testProgramName} ${inDir}sddspfit.input -pipe=out -col=MALIN.DX,Tune -terms=4 -symm=even -fitlabelformat=%.3g -generateSigmas -reviseOrders=thres=10.0 | sddsconvert -pipe=in $outFile -ascii"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddspfit\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                            -standardFile ${inDir}sddspfit.output3 -testFile $outFile
                        if {$valid} {
                            set execute "{$testProgramName} ${inDir}sddspfit.input2 -pipe=out -col=MALIN.DX,Tune -terms=4 -symm=even -fitlabelformat=%.3g -generateSigmas -reviseOrders=thres=10.0 | sddsconvert -pipe=in $outFile -ascii"
                            if [catch {eval exec $execute} results] {
                                append finalResults "sddspfit\n$execute\n$execute\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddspfit.output4 -testFile ${outFile}
                                if {$valid} {
                                    optionsPassed -pass {generateSigmas reviseOrders}
                                    set execute "{$testProgramName} ${inDir}sddspfit.input3  -pipe=out -col=Parameter,psiy -generate -order=0,1 | sddsconvert -pipe=in $outFile -ascii"
                                    if [catch {eval exec $execute} results] {
                                        append finalResults "sddspfit\n$execute\n$execute\n$results\n"
                                    } else {
                                        set valid 0
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                          -standardFile ${inDir}sddspfit.output5 -testFile ${outFile}
                                        if {$valid} {
                                            optionsPassed -pass {orders}
                                            set returnValue 1
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
if 0 {
    set execute "{$testProgramName} ${inDir}sddspfit.input2 -pipe=out -col=MALIN.DX,Tune -terms=4 -symm=even -fitlabelformat=%.3g -generateSigmas -reviseOrders=thres=10.0 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspfit\n$execute\n$execute\n$results\n"
        return 0
    }
    set vaild 0
    compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddspfit.output4 -testFile ${outFile}
    if {!$valid} {
        return 0
    }
    optionsPassed -pass {generateSigmas reviseOrders}
    set execute "{$testProgramName} ${inDir}sddspfit.input3  -pipe=out -col=Parameter,psiy -generate -order=0,1 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspfit\n$execute\n$execute\n$results\n"
        return 0
    }
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddspfit.output5 -testFile ${outFile}
    if {!$valid} {
        return 0
    }
    optionsPassed -pass {orders}
}
    return $returnValue
}

proc test_sddsplot {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    global replacement
    APSSetVarAndUpdate status $outFile
    set execute "{$testProgramName} ${inDir}sddsplot.input1 -parameterName=nux,nuy  -graphic=symbol  -range=xminimum=0.7,yminimum=0.3,xmaximum=1.0,ymaximum=0.4 -scale=0.75,1.0,0.3,0.4 -filenamesOnTopline  -topTitle   -xLabel=use=description,units -legend -yLabel=use=symbol,units  -device=postscript -output=${outFile}1 -topline=TEST {-title=Twiss parameters}  "  
    
   
    if [catch {eval exec $execute } results] {
        append finalResults "sddsplot\n$execute\n$results\n"
    } else {
        if [catch {exec diff --ignore-matching-lines=%%Creator --ignore-matching-lines=%%CWD ${inDir}sddsplot.output1 ${outFile}1 } results] {
	   append finalResults "diff ${inDir}sddsplot.output1 ${outFile}1\n$results\n"
	   eval exec display ${outFile}1 &
	   eval exec display ${inDir}sddsplot.output1 &
	   set replacement(old) ${inDir}sddsplot.output1
	   set replacement(new) ${outFile}1
	} else { 
	   optionsPassed -pass {parameterNames range scales  filenamesOnTopline dateStamp topTitle xLabel yLabel title legend topline device output  listDevices }
	   
	   set execute "{$testProgramName} ${inDir}sddsplot.input1 -columnNames=s,beta? -graphic=symbol,vary=type -split=pages -fromPage=1 -toPage=2 -layout=2,2 -separate=page -filenamesOnTopline  -labelSize=0.03  -zoom=yFactor=0.85 -lspace=1,1,1,1  -linetypeDefault=1  -string=PEAK,xCoordinate=15,yCoordinate=15,angle=0  -legend  -aspectRation=1 -endPanel -columnNames=s,etax -graphic=line,type=1 -fromPage=1 -toPage=1 -legend -tickSetting=ygrid -subTickSettings=ygrid -axes=y  -mode=y=logarithmic -newPanel  -swap -device=postscript -output=${outFile}2 "
	   if [ catch {eval exec $execute } results] {
	      append finalResults "sddsplot\n$execute\n$results\n"
	   } else {
	      if [catch {exec diff --ignore-matching-lines=%%Creator --ignore-matching-lines=%%CWD ${inDir}sddsplot.output2 ${outFile}2 } results] {
	         append finalResults "diff ${inDir}sddsplot.output2 ${outFile}2 \n$results\n"
		 eval exec display ${outFile}2 &
	         eval exec display ${inDir}sddsplot.output2 &
		 set replacement(old) ${inDir}sddsplot.output2
	         set replacement(new) ${outFile}2
	      } else {
                  optionsPassed -pass {columnNames graphic swap layout string separate fromPage toPage  split labelSize swap lSpace tickSettings aspectRatio linetypeDefault newPanel endPanel subTickSettings axes mode zoom }
		 
		  set execute "{$testProgramName} ${inDir}sddsplot.input1  -graphic=symbol,vary=subtype  -columnNames=s,beta? -stagger=yIncrement=20,dataNames -yScalesGroup=id=beta -legend -sample=5 -columnNames=s,etax -yScalesGroup=id=eta -legend  -nameScan=all ${inDir}sddsplot.input2 -presparse=1 -sparse=4 -sever -unsuppressZero=x,y -factor=xMultiplier=1.5 -offset=xchange=-4  -limit=xMinimum=4 -device=postscript -output=${outFile}3 "
		  if [catch {eval exec $execute } results] {
		     append finalResults "sddsplot\n$execute\n$results\n"
		  } else {
		     if [catch {exec diff --ignore-matching-lines=%%Creator --ignore-matching-lines=%%CWD ${inDir}sddsplot.output3 ${outFile}3 } results] {
		        append finalResults "diff ${inDir}sddsplot.output3 ${outFile}3\n$results\n"
			eval exec display ${outFile}3 &
			eval exec display ${inDir}sddsplot.output3 &
			set replacement(old) ${inDir}sddsplot.output3
	                set replacement(new) ${outFile}3
		     } else {
		        optionsPassed -pass { stagger yScalesGroup presparse sparse server sample namescan  unsuppressZero factor offset limit }
			
			set execute "{$testProgramName} ${inDir}sddsplot.input3  -columnName=SectorName,Pressure -graphic=impulse,thickness=2,vary=subtype,type=1 -fromPage=2 -toPage=5 -sameScale=x,y -split=pages -separate=pages -noBorder -noLabels -noScales  -layout=2,2  -columnNames=SectorName,Pressure -graphic=symbol -fromPage=1 -toPage=1 -noLabels -noScales -omniPresent -device=postscript -output=${outFile}4 -verticalPrint=down "
			if [catch { eval exec $execute } results ] {
			   append finalResults "sddsplot\n$execute\n$results\n"
			} else {
                           if [ catch {exec diff --ignore-matching-lines=%%Creator --ignore-matching-lines=%%CWD ${inDir}sddsplot.output4 ${outFile}4 } results] {
			      append finalResults "diff ${inDir}sddsplot.output4 ${outFile}4\n$results\n"
			      eval exec display ${outFile}4 &
			      eval exec display ${inDir}sddsplot.output4 &
			      set replacement(old) ${inDir}sddsplot.output4
	                      set replacement(new) ${outFile}4
			   } else {
			      optionsPassed -pass { sameScale noBorder noLabels noScales verticalPrint omniPresent}
			      
			      set returnValue 1
			   }   			
			}  
		     }
		  }
	      }
	   }  
	}   
    }	      
    
    return $returnValue

}

proc test_sddsprintout {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsprintout.input -columns=* -parameters=* -fromPage=2 -toPage=6 -width=100 {-title=this is the title} > $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsprintout\n$execute\n$results\n"
    } else {
	if [catch {exec tcomp ${inDir}sddsprintout.output $outFile} results] {
	    append finalResults "sddsprintout\n$execute\n$results\n"
	} else {
	    optionsPassed -pass {columns parameters fromPage toPage width title}
	    set execute "sddsprocess ${inDir}sddsprintout.input -pipe=out | {$testProgramName} -pipe -columns=* -parameters=* -noTitle -noLabels > $outFile"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsprintout\n$execute\n$results\n"
	    } else {
		if [catch {exec tcomp ${inDir}sddsprintout.output2 $outFile} results] {
		    append finalResults "sddsprintout\n$execute\n$results\n"
		} else {
		    optionsPassed -pass {pipe noTitle noLabels}
		    set execute "{$testProgramName} ${inDir}sddsprintout.input -columns=* -parameters=* -spreadsheet=delimiter=& > $outFile"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddsprintout\n$execute\n$results\n"
		    } else {
			if [catch {exec tcomp ${inDir}sddsprintout.output3 $outFile} results] {
			    append finalResults "sddsprintout\n$execute\n$results\n"
			} else {
			    optionsPassed -pass {spreadsheet}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddsprocess {args} {
    set returnValue 1
    global finalResults
    APSStrictParseArguments {testProgramName inDir outFile}
    global pipe_sddsprocess filter_sddsprocess match_sddsprocess process_sddsprocess
    if {$pipe_sddsprocess || $filter_sddsprocess || $match_sddsprocess || $process_sddsprocess} {
        if [catch {match_test_process -testProgramName $testProgramName -inDir $inDir} result] {
            APSSetVarAndUpdate status "match_test_process failed: $result"
            return 0
        }
        optionsPassed -pass {pipe filter match}
    }
    global convertUnits_sddsprocess rpnDefinitionsFiles_sddsprocess  rpnExpression_sddsprocess
    if {$convertUnits_sddsprocess || $rpnDefinitionsFiles_sddsprocess || $rpnExpression_sddsprocess} {
        if [catch {analyse_test_process -testProgramName $testProgramName -inDir $inDir -outFile $outFile} result] {
            append finalResults "\nanalyse_test_process failed: $result"
            return 0
        }
        optionsPassed -pass {convertUnits rpnDefinitionsFiles rpnExpression }
    }
    global define_sddsprocess redefine_sddsprocess 
    if {$define_sddsprocess || $redefine_sddsprocess} {
        set execute "rowstat_test_process -testProgramName $testProgramName  -outFile $outFile"
      
        if [catch {eval $execute} result] {
            append finalResults "sddsprocess\n$execute\n$result\n"
            return 0
        } else {
            set execute "runstats_test_process -testProgramName $testProgramName -inDir $inDir"
            if [catch {runstats_test_process -testProgramName $testProgramName -inDir $inDir -outFile $outFile} result] {
                APSSetVarAndUpdate status "runstats_test_process failed: $result"
                return 0
            }
            optionsPassed -pass {define redefine}
        }
    }
    global scan_sddsprocess 
    if $scan_sddsprocess {
        set execute "$testProgramName ${inDir}sddsprocess.input1.gz \"-match=col,ControlName=S*A:P*,ControlName=S*B:P*,|\" -match=col,IsNumerical=y -scan=col,Sector,ControlName,S%ld,type=long -scan=col,Value1,ValueString,%lf -scan=col,Value2,ValueString,%le,units=mm -pipe=out | sddsconvert -pipe=in $outFile -ascii"
        if [catch {eval exec $execute} result] {
            append finalResults "$testProgramName\n$execute\n$result\n"
            return 0
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.scan.out \
              -testFile $outFile -execute $execute
            if $valid {
                optionsPassed -pass {scan}
            } else {return 0}
        }
    }
    global test_sddsprocess
    if $test_sddsprocess {
        set execute "$testProgramName ${inDir}sddsprocess.input3 -scan=col,Value,ValueString,%lf -pipe=out | $testProgramName -pipe \"-test=par,n_rows 0 >\" \"-test=col,Value MinimumValue > Value MaximumValue < &&\" | sddsconvert -pipe=in $outFile -ascii"
        if [catch {eval exec $execute} result] {
            append finalResults "$testProgramName\n$execute\n$result\n"
            return 0
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.test.out \
              -testFile $outFile -execute $execute
            if $valid {
                optionsPassed -pass {test}
            } else {return 0}
        }
    }
    global numberTest_sddsprocess
    if $numberTest_sddsprocess {
        set execute "$testProgramName ${inDir}sddsprocess.input2 -pipe=out -numberTest=col,ValueString | $testProgramName -pipe -scan=col,Value,ValueString,%lf | sddsconvert -pipe=in $outFile -ascii"
        if [catch {eval exec $execute} result] {
            append finalResults "$testProgramName\n$execute\n$result\n"
            return 0
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.numberTest.out \
              -testFile $outFile -execute $execute
            if $valid {
                optionsPassed -pass {numberTest}
            } else {return 0}
        }
    }
    global clip_sddsprocess fclip_sddsprocess
    if {$clip_sddsprocess || $fclip_sddsprocess} {
        set execute "$testProgramName ${inDir}sddsprocess.input2 -pipe=out -clip=10,20 -fclip=0.1,0.2 | $testProgramName -pipe -clip=100,150,invert -fclip=0.2,0.2,invert | sddsconvert -pipe=in -ascii $outFile"
        if [catch {eval exec $execute} result] {
            append finalResults "$testProgramName\n$execute\n$result\n"
            return 0
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.clip.out \
              -testFile $outFile -execute $execute
            if $valid {
                optionsPassed -pass {clip fclip}
            } else {return 0}
        }
    }
    #test sparse
    set execute "$testProgramName ${inDir}sddsprocess.input4 -pipe=out -sparse=5,0 \
          \"-redefine=col,index,i_row\"  \"-filter=col,index,0,1053\"  \
          \"-define=col,time,index 0.48824420000000002 * 5 * 5.0 / 20.0 -,units=ms\" \
          \"-filter=col,time,-20.1,495.0\" \
          \"-define=col,BMvout,B:BM:PSVoltageWF 32768 +\"  \
          \"-redefine=col,BMvout,BMvout 32768 > ? BMvout 32768 3.0 * - : BMvout 32768 - $ \"  \
          \"-redefine=col,BMvout,BMvout 0.1220722 * 4200.0 +,units=Volts\" \
          \"-define=col,BMcurrent,B:BM:CurrentWF 32768 +\" \
          \"-redefine=col,BMcurrent,BMcurrent 32767 > ? BMcurrent 32767 - : BMcurrent 32767 + $ \" \
          \"-define=col,BMpsError,B:BM:PSErrorWF 32767 +\" \
          \"-redefine=col,BMpsError,BMpsError 32767 > ? BMpsError 32767 - : BMpsError 32768 + $ \" \
          \"-redefine=col,BMpsError,BMpsError 0.06103608 * -2000.0 +,units=Amperes\" \
          \"-define=col,BMpsComp,B:BM:PSCompWF 32768 +\" \
          \"-redefine=col,BMpsComp,BMpsComp 32767 > ? BMpsComp 32768 - : BMpsComp 32768 + $ \" \
          \"-redefine=col,BMpsComp,BMpsComp 0.00030518 * -10.0 +,units=Volts\" \
          \"-process=BMcurrent,slope,BMslope,functionOf=index,lowerLimit=96,upperLimit=301\" \
          \"-process=BMcurrent,intercept,BMzero,functionOf=index,lowerLimit=96,upperLimit=301\" \
 \"-define=col,BMfitI,index BMzero BMslope / -1.0 * < ? 0.0 : BMslope index * BMzero + $ ,units=Amperes\" \
 \"-define=col,BMfitError,BMcurrent BMfitI -,units=Amperes\" \
 \"-define=col,BMdeltaI/I,BMfitI 0.001 < ? 1.0 : BMfitError BMfitI / $ \" \
 \"-redefine=param,BMslope,BMslope 0.48824420000000002 / 5 / 5.0 *,units=Amperes/ms\" \
 \"-redefine=param,BMzero,-1.0 BMzero * BMslope / 20.0 -,units=ms\" \
 | sddsconvert -pipe=in $outFile \
 -delete=col,B:BM:PSVoltageWF,B:QF:PSVoltageWF,B:QD:PSVoltageWF,B:SF:PSVoltageWF,B:SD:PSVoltageWF,B:BM:CurrentWF,B:QF:CurrentWF,B:QD:CurrentWF,B:SF:CurrentWF,B:SD:CurrentWF,B:BM:PSErrorWF,B:QF:PSErrorWF,B:QD:PSErrorWF,B:SF:PSErrorWF,B:SD:PSErrorWF,B:BM:PSCompWF,B:QF:PSCompWF,B:QD:PSCompWF,B:SF:PSCompWF,B:SD:PSCompWF  -rename=col,index=index -ascii"
    
    if [catch {eval exec $execute} result] {
        append finalResults "$testProgramName\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.sparse.out \
          -testFile $outFile -execute $execute
        if $valid {
            set valid 0
            compareOutputTitle -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.sparse.out \
              -testFile $outFile -execute $execute
            if $valid {
                optionsPassed -pass {sparse}
            } else {return 0}
        } else {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sddsprocess.input5 \"-match=col,ControlName=*\\\[HV]\\\*\" \
                -pipe=out -edit=col,DeviceName,ControlName,%/:CurrentAO// -reedit=col,ControlName,ai/SFB:/ \
                -print=par,CorrectorType,Dynamic -reprint=par,CorrectorType,%sType,CorrectorType \
                -delete=col,ControlType \
                -print=col,ControlType,pv -reprint=col,ControlType,%s%s,Category,ControlType \
                -format=col,FormatValue,ValueString,doubleFormat=%6.3e,longFormat=%ld,stringFormat=%s \
                | sddsconvert -pipe=in -ascii $outFile"

    if [catch {eval exec $execute} result] {
        append finalResults "$testProgramName\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.edit.out \
          -testFile $outFile -execute $execute
        if $valid {
            optionsPassed -pass {edit reedit print reprint format}
        } else {
            return 0
        }
    }
    #process test
    set execute "$testProgramName ${inDir}sddsprocess.input6 -pipe=out \"-process=*CurrentWF,max,%sMax\" \
                   \"-process=*CurrentWF,min,%sMinIndex,functionOf=Index,position\" \
                   \"-process=*CurrentWF,ave,%sMean,head=5,tail=50\" \
                   \"-process=*CurrentWF,stand,%sStdev,fhead=0.1,ftail=0.2\" \
                   \"-process=*CurrentWF,mad,%sMad,tail=100\" \
                   \"-process=*CurrentWF,sigma,%sSigma,head=100\" \
                   \"-process=*CurrentWF,percentile,%sP10,perc=10\" \
                   \"-process=*CurrentWF,drange,%sDrange\" \
                   \"-process=*CurrentWF,qrange,%sQrange\" \
                   \"-process=*CurrentWF,median,%sMedian\" \
                   -process=Index,count,Count \
                   -process=B:BM:CurrentWF,rms,B:BM:CurrentWFRMS,top=8680,bot=8670 \
                   \"-process=*CurrentWF,sum,%sWeightedSum,weightBy=Index,functionOf=Index,low=50,upper=100\" \
                   \"-process=*CurrentWF,spread,%sSpread\" \
                   \"-process=*CurrentWF,slope,%sSlope,functionOf=Index\" \
                   \"-process=*CurrentWF,intercept,%sIntercept,functionOf=Index\" \
                   \"-process=*CurrentWF,lfsd,%sLFSD,functionOf=Index\" \
                   \"-process=*CurrentWF,risetime,%sRisetime,functionOf=Index\" \
                   \"-process=*CurrentWF,falltime,%sFalltime,functionOf=Index\" \
                   \"-process=*CurrentWF,center,%sCenter,functionOf=Index\" \
                   -process=IndexColumn,first,First%s \
                   -process=IndexColumn,last,Last%s \
                   \"-delete=par,*TimeStamp*,File*\" \
                   -ifis=par,StartTime \
                   -ifnot=col,TestColumn -print=col,TestColumn,%lf,StartTime \
                  | sddscollapse -pipe \
                  | sddstranspose -pipe \
                  | sddsconvert -pipe=in -ascii $outFile"
    if [catch {eval exec $execute} result] {
        append finalResults "sddsquery\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsprocess.process1.out -testFile $outFile
        if {!$valid} {
            return 0
        } else {
            set valid 0
            compareOutputTitle -testProgramName $testProgramName \
              -standardFile ${inDir}sddsprocess.process1.out \
              -testFile $outFile -execute $execute
            if !$valid {
                return 0
            } else {
                set execute "$testProgramName ${inDir}sddsprocess.input7 -pipe=out \
                         \"-delete=par,*\" \
                         \"-process=Prof*,baselevel,%sBase,functionOf=yCoord\" \
                         \"-process=Prof*,toplevel,%sTop,functionOf=yCoord\" \
                         \"-process=Prof*,amplitude,%sAmplitude,functionOf=yCoord\" \
                         \"-process=Prof*,risetime,%sRise,functionOf=yCoord\" \
                         \"-process=Prof*,falltime,%sFall,functionOf=yCoord\" \
                         \"-process=Prof*,center,%sCenter,functionOf=yCoord\" \
                         \"-process=Prof*,fwhm,%sFWHM,functionOf=yCoord\" \
                         \"-process=Prof*,fwtm,%sFWTM,functionOf=yCoord\" \
                         \"-process=Prof*,fwha,%sFWHA,functionOf=yCoord\" \
                         \"-process=Prof*,fwta,%sFWTA,functionOf=yCoord\" \
                         \"-process=Prof*,zerocrossing,%sZeroOf,functionOf=yCoord,offset=%sBase,invert=offset\" \
                         | sddscollapse -pipe \
                         | sddstranspose -pipe \
                         | sddsconvert -pipe=in -ascii $outFile"
                if [catch {eval exec $execute} result] {
                    append finalResults "sddsprocess\n$execute\n$result\n"
                    return 0
                } else {
                    set valid 0
                    compareOutput -testProgramName $testProgramName -execute $execute \
                      -standardFile ${inDir}sddsprocess.process2.out -testFile $outFile
                    if !$valid {
                        return 0
                    } else {
                        set valid 0
                        compareOutputTitle -testProgramName $testProgramName \
                          -standardFile ${inDir}sddsprocess.process2.out \
                          -testFile $outFile -execute $execute
                        if $valid {
                            set execute "$testProgramName ${inDir}sddsprocess.input4 -pipe=out \
                                   -process=*WF,percentile,%sP85,percentLevel=85 \
                                   -process=*WF,percentile,%sP15,percentLevel=15 \
                                   -process=*WF,prange,%sPRange70,percentLevel=70 \
                                 | sddscollapse -pipe \
                                 | sddscollect -pipe -collect=suffix=P85 -collect=suffix=P15 -collect=suffix=PRange70 \
                                 | sddsconvert -pipe=in $outFile -del=par,* "
                            if [catch {eval exec $execute} result] {
                                append finalResults "$testProgramName\n$execute\n$result\n"
                                return 0
                            } else {
                                set valid 0
                                if [catch {exec sddsprocess $outFile -pipe=out \
                                               "-define=col,PRangeDiff,P85 P15 - PRange70 - abs" \
                                               | sddsprocess -pipe "-test=col,PRangeDiff 0 >" -nowarnings \
                                               | sdds2stream -rows=bar -pipe} result] {
                                    append finalResults "unable to check the prange result\n$execute\n$result\n"
                                    return 0
                                }
                                if $result {
                                    return 0
                                } else {
                                    compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.output5 \
                                        -testFile $outFile -execute $execute
                                    if $valid {
                                        optionsPassed -pass {process}
                                    } else {
                                        return 0
                                    }
                                }
                            }
                        } else {return 0}
                    } 
                }
            } 
        }
    }
    set execute "$testProgramName ${inDir}sddsprocess.input7 -pipe=out \
                 -ifnot=col,Index -define=col,Index,i_row,type=long \
                 -ifnot=par,Count -process=Index,count,Count \
                 -ifis=col,yCoord \"-define=col,xCoord,yCoord 1.0 -\" \
                 | $testProgramName -pipe \
                 -ifis=par,Count -print=par,NumberOfRows,%lfRows,Count \
                 -cast=col,x,xCoord,long \
                 | sddsconvert -pipe=in -ascii -retain=col,Index,xCoord,x $outFile"
    if [catch {eval exec $execute} result] {
        append finalResults "sddsprocess\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsprocess.isnot.out -testFile $outFile
        if $valid {
            optionsPassed -pass {ifis ifnot cast} 
        } else {return  0}
    }
    set execute "$testProgramName ${inDir}sddsprocess.isnot.out $outFile -sample=0.2"
    if [catch {eval exec $execute} result] {
        append finalResults "sddsprocess\n$execute\n$result\n"
        return 0
    } else {
        optionsPassed -pass {sample} 
    }
    #the Index column value is >=0, so if noWarnings option is not provide, error will be caught
    set execute "$testProgramName ${inDir}sddsprocess.isnot.out $outFile -filter=col,Index,-1,-0.5 -noWarnings"
    if [catch {eval exec $execute} result] {
        append finalResults "sddsprocess\n$execute\n$result\n"
        return 0
    } else {
        optionsPassed -pass {noWarnings} 
    }
    #test system
    set execute "$testProgramName ${inDir}sddsprocess.input8 -pipe=out \
           \"-redefine=column,IntegratedStrength,IntegratedStrength BnLMultiplier * Sign *,units=T\" \
           \"-print=column,ExcitationFile,/home/helios/oagData/linac/magnets/%s.excitation,ElementName\" \
           \"-print=column,InterpCommand,sddsinterp -at=%21.15e %s /dev/null -column=IntegratedStrength\\\\,Current -print=bare\\\\,stdout -aboveRange=extrapolate -belowRange=value=0 | token -last,IntegratedStrength,ExcitationFile\" \
           -system=column,ValueString,InterpCommand \
           -scan=column,Current,ValueString,%lf,type=double,units=A \
           \"-define=column,OverLimit,Current abs SupplyLimit > ? 1 : 0 \$ ,type=long\" \
           -edit=column,Beamline,ControlName,S/:/100D \
           \"-define=column,Momentum,pCentral 0.51099906 *,units=MeV/c\" \
           | sddsconvert -pipe=in -ascii $outFile \
           -retain=column,ElementName,ControlName,Current,Beamline,IntegratedStrength,pCentral,Momentum,GeometricIntegratedStrength,SupplyLimit,OverLimit"
   
    if [catch {eval exec $execute} result] {
        append finalResults "sddsprocess\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsprocess.system.out -testFile $outFile
        if {$valid} {
            optionsPassed -pass {system}
        } else {return 0}
    }
    if $returnValue {
        #note that verbose and summarize do not beed to be tested, since they print messages to stderr
        optionsPassed -pass {verbose summarize}
    }
    #test rpn string functions
    set execute {$testProgramName ${inDir}sddsprocess.input9 $outFile \
                   "-define=col,Is_SteeringPS,Category \"SteeringPS\" streq ? 1 : 0 $ " \
                   "-define=par,Is_MainPS,PowerSupply \"MainPS\" streq ? 1 : 0 $ " \
                   "-define=col,Is_H_Corr,ControlName \"*:H*\" strmatch ? 1 : 0 $ "}
    if [catch {eval exec $execute} result] {
        append finalResults "sddsprocess\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsprocess.output3 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {define}
        } else {return  0}
    }
    set execute {$testProgramName ${inDir}sddsprocess.input9 $outFile \
                   "-define=column,IsHOrV,ControlName \"*:H*\" strmatch ControlName \"*:V*\" strmatch || ? 1 : 0 $ " \
                   "-define=column,IsMainNotQuad,PowerSupply \"MainPS\" streq  ControlName \"*:Q*\" 
strmatch ! && ? 1 : 0 $ "}
    
    if [catch {eval exec $execute} result] {
        append finalResults "sddsprocess\n$execute\n$result\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsprocess.output4 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {define}
        } else {return 0}
    }
    return $returnValue
}



##########procedures for sddsprocess test########################
proc match_test_process {args} {
    #this procedure is to test the match filter added to -process option
    #of sddsprocess by shang
    set num 0
    APSStrictParseArguments {testProgramName inDir}
    
    set input ${inDir}aps.twi
    #test1: process numeric column
    #get the result from previous options
    if [catch {exec $testProgramName $input -match=col,ElementType=QUAD \
                 -process=s,last,s0,head=10 \
                 -pipe=out | sdds2stream -pipe -param=s0} s0 ] {
        return -code error "process error1: $s0"
    }
  
    #combin match and head filter
    if [catch {exec $testProgramName $input \
                 -process=s,last,s0,head=10,match=ElementType,value=QUAD \
                 -pipe=out | sdds2stream -pipe -param=s0 } s1] {
       return -code error "process error2: $s1" 
    }
   
    if {$s1 != $s0} {
        return -code error "test_match_process1 failed."
    }
    
    if [catch {exec $testProgramName $input -match=col,ElementType=QUAD -process=s,last,s0,head=1 \
                 -pipe=out | sdds2stream -pipe -param=s0} s0] {
        return -code error "process error3: $s0" 
    }
   
    #combine match and head filter
    if [catch {exec $testProgramName $input \
                 -process=s,last,s0,match=ElementType,value=QUAD,head=1 \
                 -pipe=out | sdds2stream -pipe -param=s0 } s1] {
        return -code error "process error4: $s1"
    }
    
    
    if {$s1 != $s0} {
        return -code error "test_match_process2 failed."
    }

    if [catch {exec $testProgramName $input \
                 -match=col,ElementType=QUAD -process=s,last,s0,tail=10 \
                 -pipe=out | sdds2stream -pipe -param=s0} s0 ] {
        return -code error "process error5: $s0"
    }
   
    #combin match and tail filter
    if [catch {exec $testProgramName $input \
                 -process=s,last,s0,match=ElementType,value=QUAD,tail=10 \
                 -pipe=out | sdds2stream -pipe -param=s0 } s1 ] {
        return -code error "process error6: $s1"
    }
 
    if {$s1 != $s0} {
        return -code error "test_match_process3 failed."
    }
    #combin match and tail filter, different order (order should not matter)
    if [catch {exec $testProgramName $input \
                 -process=s,last,s0,tail=10,match=ElementType,value=QUAD \
                 -pipe=out | sdds2stream -pipe -param=s0 } s1 ] {
        return -code error "process error7: $s1"
    }
   
    if {$s1 != $s0} {
        return -code error "test_match_process4 failed."
    }
    
    #test average function
    if [catch {exec $testProgramName $input -match=col,ElementType=QUAD -process=s,average,s0 \
                 -pipe=out | sdds2stream -pipe -param=s0} s0] {
        return -code error "process error8: $s0"
    }
 
    #match filter only
    if [catch {exec $testProgramName $input -process=s,average,s0,match=ElementType,value=QUAD \
                 -pipe=out | sdds2stream -pipe -param=s0 } s1] {
        return -code error "process error9: $s1"
    }
    
    if {$s1 != $s0} {
        return -code error "test_match_process5 failed."
    }

    #last function
    if [catch {exec $testProgramName $input -match=col,ElementType=QUAD \
             -process=s,last,s0,function=s,lower=20,upper=30 \
                 -pipe=out | sdds2stream -pipe -param=s0} s0] {
        return -code error "process error10: $s0"
    }
    
    #combine match filter with function filter
    if [catch {exec $testProgramName $input \
             -process=s,last,s0,match=ElementType,value=QUAD,function=s,lower=20,upper=30 \
                 -pipe=out | sdds2stream -pipe -param=s0 } s1 ] {
        return -code error "process error11: $s1"
    }
   
    if {$s1 != $s0} {
        return -code error "test_match_process6 failed."
    }
    
    set input2 ${inDir}x1.twi
    #test2: process string column
    if [catch {exec $testProgramName $input2 -match=col,ElementType=DRIF \
             -process=ElementName,first,foundName,tail=10 -pipe=out | \
        sdds2stream -pipe -par=foundName } name1] {
        return -code error "process error12: $name1"
    }
    
    if [catch {exec $testProgramName $input2 \
             -process=ElementName,first,foundName,match=ElementType,value=DRIF,tail=10 \
                 -pipe=out | sdds2stream -pipe -par=foundName } name2] {
        return -code error "process error13: $name2"
    }
  
    if [string compare $name1 $name2]!=0 {
        return -code error "test_match_process7 failed."
    }

    #test no matches case
   
    if [catch {exec $testProgramName $input2 \
             -process=ElementName,first,foundName,match=ElementType,value=XXXX,tail=10 \
                 -pipe=out -nowarn | sdds2stream -pipe -par=foundName } name2] {
        return -code error "process error13: $name2"
    }
   
    if [string compare $name2 "_NoResultFound_"]!=0 {
        return -code error "test_match_process8 failed."
    }
}

#this part is based on Michael's analys script test
proc analyse_test_process {args} {
    global finalResults
    set oldDir [pwd]
    APSStrictParseArguments {testProgramName inDir outFile}
    
   # cd $inDir
    set execute "sddsconvert ${inDir}bztx016-all.sdds \
                 -pipe=out -rename=col,Braw=Braw1 -binary \
                 | sddsxref -pipe ${inDir}bztx016-all.sdds -take=Braw \
                 | $testProgramName -pipe \
                 \"-define=column,BrawError,Braw Braw1 -\" \
                 -process=BrawError,stand,BrawErrorStDev \
                 -process=BrawError,count,Count \
                 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
      #  cd $oldDir
        return -code error $results
    }
    APSAddToTmpFileList -ID 1 -fileList /tmp/junk1
    set valid 0
    set finalResults ""
    compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.output1 \
      -testFile $outFile -execute $execute
    if !$valid {
       # cd $oldDir
        return -code error $finalResults
    }
    set plotfile ""
    set file [list  bztx0160.dat.gz  bztx0161.dat  bztx0162.dat.Z]
    foreach fl $file {
        set nfile /tmp/${fl}p
        lappend plotfile $nfile
        if [catch {exec sddsconvert ${inDir}$fl -pipe=out -binary \
                     | sddssort -col=Braw -pipe \
                     | sddsconvert -pipe -ascii \
                     | sddsbreak -pipe -rowlimit=1 \
                     | sddsconvert -pipe -binary \
                     | sddscombine -pipe -merge \
                     | sddssort -col=z -pipe \
                     | $testProgramName -pipe=in $nfile \
                     -rpndefinitions=${inDir}rpnsmooth.rpn \
                     -convert=col,Braw,T,G,1e-4 \
                     -convert=col,Bcmp,T,G,1e-4 -convert=col,I,A,A,0.6 \
                     -convert=column,z,m,inch,0.0254 "-define=col,B,Braw Isp * I /,units=T" \
                     -define=col,Bnorm,B -process=B,max,%smax \
                     "-redefine=column,Bnorm,Bnorm Bmax /,symbol='B/B\$bo\$n'" \
                     -process=Bnorm,risetime,zRise%s,func=z \
                     -process=Bnorm,falltime,zFall%s,func=z \
                     -process=Bnorm,center,zc,func=z \
                     -process=Bnorm,min,BnormT1,bottom=0.1 \
                     -process=Bnorm,max,BnormT2,top=0.9 \
                     -process=Bnorm,spread,BnormT3,top=0.9,bottom=0.1 \
                     "-rpnexpression=n_rows &Bnorm  n_rows mal sto &Btmp smootharray" \
                     "-define=column,Bsmoothed,i_row &Btmp \[" \
                     "-define=col,zOffset,z zc -,units=m" } result] {
           # cd $oldDir
            return -code error $result
        }
        
        if [catch {exec $testProgramName $nfile -filter=col,zOffset,-1e10,0 -pipe=out \
                     | sddsinteg -pipe -integrate=Bnorm -versus=zOffset \
                     | $testProgramName -pipe=in ${outFile}analyse.int -process=BnormInteg,last,%s} result] {
           # cd $oldDir
            return -code error $result
        }
        if [catch {exec sddsxref $nfile ${outFile}analyse.int $nfile.1 -leave=* \
                     -transfer=param,BnormInteg -noWarning} result] {
            #cd $oldDir
            return -code error $result
        }
        
        if [catch {exec $testProgramName $nfile.1 $nfile -noWarning \
                     "-defi=param,L,BnormInteg 2 *,symbol='L\$beff\$n',units=m" \
                     "-define=param,BL,Bmax L *,symbol='\$sI\$eBdl',units=T-m" } result] {
           # cd $oldDir
            return -code error $result
        }
        file delete -force $nfile.1
    }
    APSAddToTmpFileList -ID 1 -fileList $plotfile
    #compare results.sdds
    set finalResults ""
    set valid 0
    set execute "sddscombine $plotfile -pipe=out | \
                 sddscollapse -pipe | sddsconvert -pipe -ascii \
                 | sddsbreak -pipe -rowlimit=1 | sddscombine -pipe -merge \
                 | sddsconvert -pipe -rename=col,Isp=current \
                 | sddsconvert -pipe -ascii | sddssort \
                 -pipe=in ${outFile}results.sdds -column=current,increasing"
    if [catch {eval exec $execute} result] {
       # cd $oldDir
        return -code error $result
    }
    APSAddToTmpFileList -ID 1 -fileList /tmp/results.sdds
    compareOutput -testProgramName $testProgramName -standardFile ${inDir}sddsprocess.output2 \
      -testFile ${outFile}results.sdds -execute $execute
    if !$valid {
        #cd $oldDir
        return -code error $finalResults
    }
    #cd $oldDir
    return 1
}

#this procedure is copied from Borland's rowstatTest script
proc rowstat_test_process {args} {
    # computes statistics accross rows using sddsrowstats and sddsprocess,
    # and compares the results
    APSStrictParseArguments {testProgramName outFile}
    exec sddssequence -defi=index,type=long -seq=begin=0,end=499,delta=1 -pipe=out \
      | sddsbreak -row=100 -pipe \
      | $testProgramName -pipe -defi=col,G1,grnd -defi=col,G2,grnd -defi=col,G3,grnd \
      -defi=col,G4,grnd -defi=col,G5,grnd -defi=col,G6,grnd \
      | sddsrowstats -pipe -max=GMax,G* -min=GMin,G* \
      -mean=GMean,G* -rms=GRms,G1,G* \
      -stand=GStDev,G1,G2,G3,G4,G5,G6 \
      -sigma=GSigma,G4,G5,G6,G1,G2,G3 \
      -sum=GSum,G1,G2,G3,G* -sum=GSum2,power=2,G*,G1,G2,G3 \
      -sum=GSum4,power=4,G* \
      | $testProgramName -pipe \
      "-define=col,DeltaGMean,G1 G2 G3 G4 G5 G6 6 mean GMean -" \
      "-define=col,DeltaGMax,G1 G2 G3 G4 G5 G6 6 maxn GMax -" \
      "-define=col,DeltaGMin,G1 G2 G3 G4 G5 G6 6 minn GMin -" \
      "-define=col,DeltaGSum,G1 G2 G3 G4 G5 G6 6 sumn GSum -" \
      "-define=col,DeltaGSum2,G1 sqr G2 sqr G3 sqr G4 sqr G5 sqr G6 sqr 6 sumn GSum2 -" \
      "-define=col,DeltaGRms,G1 sqr G2 sqr G3 sqr G4 sqr G5 sqr G6 sqr 6 mean sqrt GRms -" \
      "-define=col,DeltaGSum4,G1 sqr sqr G2 sqr sqr G3 sqr sqr G4 sqr sqr G5 sqr sqr G6 sqr sqr 6 sumn GSum4 -" \
      "-define=col,DeltaGStDev,G1 G2 G3 G4 G5 G6 6 stats pop GStDev -" \
      "-define=col,DeltaGSigma,G1 G2 G3 G4 G5 G6 6 stats pop 6 sqrt / GSigma -" \
      | $testProgramName -pipe -process=Delta*,largest,%sLargest \
      | tee ${outFile}rowstatTest.sdds \
      | sddscollapse -pipe \
      | sddsprintout -pipe=in $outFile -col=Delta*,format=%10.3e,editlabel=%/Largest// 
#    APSAddToTmpFileList -ID 1 -fileList /tmp/rowstatTest.sdds
}

#this procedure is copied from Borland's runstatsTest
# computes blocked statistics using sddsrunstats and sddsprocess, and
# compares the results.
proc runstats_test_process {args} {
    #set inDir ""
    APSStrictParseArguments {testProgramName inDir outFile}
    set total 1000
    set points 20
    
    #APSAddToTmpFileList -ID 1 -fileList "/tmp/runstatsTest.1 /tmp/runstatsTest.2"
    exec sddssequence -define=index,type=short -sequence=begin=0,n=$total,delta=1 -pipe=out \
      | $testProgramName -pipe=in ${outFile}runstatsTest.1 \
      "-define=column,G1,grnd" \
      "-define=column,G2,grnd" \
      "-define=column,R1,rnd" \
      "-define=column,R2,rnd" 
    exec sddsbreak ${outFile}runstatsTest.1 -rowlimit=$points -pipe=out \
      | $testProgramName -pipe \
      -process=??,ave,%sMean -process=??,stand,%sStDev \
      -process=??,rms,%sRMS,top=1,bot=-1 -process=??,sum,%sSum,top=0.5 \
      -process=??,sigma,%sSigma -process=??,first,%s \
      -process=??,min,%sMin,bot=-0.5 -process=??,max,%sMax \
      | sddscollapse -pipe \
      | $testProgramName -pipe \
      -process=??*,ave,%sMean \
      | sddscollapse -pipe \
      | sddscollect -pipe=in ${outFile}runstatsTest.2 \
      -collect=suffix=Mean,column=Mean1

    set largest1 [exec sddsrunstats ${outFile}runstatsTest.1 -pipe=out -points=$points -nooverlap \
                    -max=?? -min=??,bot=-0.5 -mean=?? -stand=?? \
                    -rms=??,top=1,bot=-1 -sum=??,top=0.5 -sigma=?? -sample=?? \
                    | $testProgramName -pipe \
                    -process=??*,ave,%sMean \
                    | sddscollapse -pipe \
                    | sddscollect -pipe \
                    -collect=suffix=Mean,column=Mean2 \
                    | sddsxref -pipe ${outFile}runstatsTest.2 -match=Rootname -take=Mean1 \
                    | $testProgramName -pipe "-define=column,Delta,Mean1 Mean2 -" \
                    | $testProgramName -pipe -process=Delta,largest,DeltaLargest \
                    | sdds2stream -pipe -parameter=DeltaLargest ]
    
    set largest2 [exec sddsrunstats ${outFile}runstatsTest.1 -pipe=out \
                    -window=column=index,width=$points -nooverlap \
                    -max=?? -min=??,bot=-0.5 -mean=?? -stand=?? \
                    -rms=??,top=1,bot=-1 -sum=??,top=0.5 -sigma=?? -sample=?? \
                    | $testProgramName -pipe \
                    -process=??*,ave,%sMean \
                    | sddscollapse -pipe \
                    | sddscollect -pipe \
                    -collect=suffix=Mean,column=Mean2 \
                    | sddsxref -pipe ${outFile}runstatsTest.2 -match=Rootname -take=Mean1 \
                    | $testProgramName -pipe "-define=column,Delta,Mean1 Mean2 -" \
                    | $testProgramName -pipe -process=Delta,largest,DeltaLargest \
                    | sdds2stream -pipe -parameter=DeltaLargest ]
    if {$largest1 != $largest2} {
        return -code error "$largest1 != $largest2"
    }
    #puts stderr "equal: $largest1"
}


###########end of sddsprocess test procedures ###################

proc test_sddspseudoinverse {args} {
    global diffOption
    set returnValue 0
    global finalResults
    APSStrictParseArguments {testProgramName inDir outFile}
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input1 \
                 -pipe=out -largestSingularValues=12 \
                 -weights=${inDir}sddspseudoinverse.monitors,name=Name,value=Weight \
                 | sddsconvert -pipe=in -ascii $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0;
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
      -standardFile ${inDir}sddspseudoinverse.output1 -testFile $outFile
    if {!$valid} {
        return 0
    }
    
    optionsPassed -pass {pipe largestSingularValues weights}
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input1 \
                 -pipe=out -largestSingularValues=12 -nowarnings -economy \
                 -weights=${inDir}sddspseudoinverse.monitors,name=Name,value=Weight \
                 | sddsconvert -pipe=in -ascii $outFile"
    
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0;
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
      -standardFile ${inDir}sddspseudoinverse.output1 -testFile $outFile
    if {!$valid} {
        return 0
    }
    
    optionsPassed -pass {economy}
    
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input1 $outFile \
                 -oldColumnNames=ActuatorNames -ascii -minimum=0.01 -vmatrix=${outFile}.vm \
                 -digits=4 -sFile=${outFile}.s -reconstruct=${outFile}.reconstruct -uMatrix=${outFile}.um"
    
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0
    }
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddspseudoinverse.output2 -testFile $outFile
    if {!$valid} {
        return 0
    }
    
    set valid 0
    append diffOption " -absolute"
    compareOutput -testProgramName $testProgramName -execute $execute -absolute 1 \
      -standardFile ${inDir}sddspseudoinverse.output2.vm -testFile ${outFile}.vm
    if {!$valid} {
        return 0
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute -absolute 1 \
        -standardFile ${inDir}sddspseudoinverse.output2.um -testFile ${outFile}.um
    set diffOption [join  [lreplace $diffOption end end ]]
    if {!$valid} {
        return 0
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
      -standardFile ${inDir}sddspseudoinverse.output2.s -testFile ${outFile}.s
    if {!$valid} {
        return 0
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
      -standardFile ${inDir}sddspseudoinverse.output2.reconstruct -testFile ${outFile}.reconstruct
    
    if {!$valid} {
        return 0
    }
    
    optionsPassed -pass {oldColumnNames ascii minimumSingularValueRatio vMatrix uMatrix \
                           sFile reconstruct digits}
    
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input1 $outFile \
                 -oldColumnNames=ActuatorNames -ascii -minimum=0.01 -digits=3 -root=Inverse"
    
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddspseudoinverse.output3 -testFile $outFile
    if {!$valid} {
        return 0
    }
    
    optionsPassed -pass {root digits}
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input1 $outFile \
                 -oldColumnNames=ActuatorNames -ascii -minimum=0.01 \
                 -newColumnNames=ElementName -symbol=test"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -standardFile \
      ${inDir}sddspseudoinverse.output4 -testFile $outFile -execute $execute
    if {!$valid} {
        return 0
    }
    
    set valid 0
    compareOutputTitle -testProgramName $testProgramName -standardFile \
      ${inDir}sddspseudoinverse.output4 -testFile $outFile -execute $execute
    if {!$valid} {
        return 0
    }
    
    optionsPassed -pass {symbol newColumnNames}
    
    #test new features:a)write the largestSingularValues to the parameter NumberOfSingularValuesUsed
    #b)added -deleteVectors=n1,n2,n3,... which sets the inverse singular values of n1,n2,n3 modes to 0
    set execute "$testProgramName ${inDir}sddspseudoinverse.input2 -largestSingularValues=2 $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0
    }
    
    set nlargest [exec sdds2stream $outFile -par=NumberOfSingularValuesUsed]
    if {$nlargest !=2} {
        append finalResults "sddspseudoinverse\n$execute\nwritting largestSignularValues to output file as a parameter failed"
        return 0
    }
    
    set execute "$testProgramName ${inDir}sddspseudoinverse.input2 -deleteVectors=1,2 $outFile"
    #the values of this output are all zeros
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0
    }
    set valid 0
    
    compareOutput -testProgramName  $testProgramName  -standardFile \
        ${inDir}sddspseudoinverse.output5 -testFile ${outFile} -execute $execute
    
    if {!$valid} {
        return 0    
    }
    
    #sddspseudoinverse.input2 is a 3x3 matrix, and deleteVectors does not delete the first inverse singular
    #value (index=0),
    #therefore -deleteVectors=0,1,2,3,4,.. should give the same result
    set execute "$testProgramName ${inDir}sddspseudoinverse.input2 -deleteVectors=0,1,2,3,4,5 $outFile"
    #the values of this output are all zeros
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0
    }
    set valid 0
    compareOutput -testProgramName  $testProgramName  -standardFile \
    ${inDir}sddspseudoinverse.output6 -testFile ${outFile} -execute $execute
    if {!$valid} {
        return 0
    }
    optionsPassed -pass {deleteVectors}
    set execute1 "$testProgramName  ${inDir}sddspseudoinverse.input3 ${outFile}.largest -largest=5 -sFile=${outFile}.s.largest -rec=${outFile}.rec.largest"
    set execute2 "$testProgramName  ${inDir}sddspseudoinverse.input3 ${outFile}.smallest -smallest=4 -sFile=${outFile}.s.smallest -rec=${outFile}.rec.smallest"
    if [catch {eval exec $execute1} results] {
        append finalResults "sddspseudoinverse\n$execute1\n$results\n"
        return 0
    }
    if [catch {eval exec $execute2} results] {
        append finalResults "sddspseudoinverse\n$execute2\n$results\n"
        return 0
    }
    #compare the inverse matrice generated by above two commands
    set valid 0
    compareOutput -testProgramName  $testProgramName -standardFile \
      ${outFile}.largest -testFile ${outFile}.smallest -execute $execute2
    if {!$valid} {
        return 0
    }
    set valid 0
    compareOutput -testProgramName  $testProgramName -standardFile \
      ${outFile}.s.largest -testFile ${outFile}.s.smallest -execute $execute2
    if {!$valid} {
        return 0
    }
    set valid 0
    compareOutput -testProgramName  $testProgramName -standardFile \
      ${outFile}.rec.largest -testFile ${outFile}.rec.smallest -execute $execute2
    if {!$valid} {
        return 0
    }
    
    set execute1 "$testProgramName  ${outFile}.rec.largest ${outFile}.largest.inv -sFile=${outFile}.s.largest"
    set execute1 "$testProgramName  ${outFile}.rec.smallest ${outFile}.smallest.inv -sFile=${outFile}.s.smallest"
    
    if [catch {eval exec $execute1} results] {
        append finalResults "sddspseudoinverse\n$execute1\n$results\n"
        return 0
    }
    if [catch {eval exec $execute2} results] {
        append finalResults "sddspseudoinverse\n$execute2\n$results\n"
        return 0
    }
    set valid 0
    compareOutput -testProgramName  $testProgramName -standardFile \
      ${outFile}.s.largest -testFile ${outFile}.s.smallest -execute $execute2
    if {!$valid} {
        return 0
    }
    optionsPassed -pass {smallestSingularValues}
    set execute1 "$testProgramName ${inDir}sddspseudoinverse.R2C5.input  ${outFile}.R2C5  -nowarnings -economy -sFile=${outFile}.s.R2C5"
    set execute2 "$testProgramName ${inDir}sddspseudoinverse.R9C5.input  ${outFile}.R9C5 -nowarnings -economy -sFile=${outFile}.s.R9C5"
    
    if [catch {eval exec $execute1} results] {
        append finalResults "sddspseudoinverse\n$execute1\n$results\n"
        return 0
    }
    if [catch {eval exec $execute2} results] {
        append finalResults "sddspseudoinverse\n$execute2\n$results\n"
        return 0
    }	
    set valid 0
    compareOutput -testProgramName $testProgramName -standardFile \
        ${inDir}sddspseudoinverse.R2C5.output -testFile ${outFile}.R2C5 -execute $execute1
    if {!$valid} {
        return 0
    }	 
    set valid 0	
    compareOutput -testProgramName $testProgramName -standardFile \
        ${inDir}sddspseudoinverse.s.R2C5.output -testFile ${outFile}.s.R2C5 -execute $execute1
    if {!$valid} {
        return 0
    }
    set valid 0 
    compareOutput -testProgramName $testProgramName -standardFile \
        ${inDir}sddspseudoinverse.R9C5.output -testFile ${outFile}.R9C5 -execute $execute2
    if {!$valid} {
        return 0
    }	 
    set valid 0	
    compareOutput -testProgramName $testProgramName -standardFile \
        ${inDir}sddspseudoinverse.s.R9C5.output -testFile ${outFile}.s.R9C5 -execute $execute2
    if {!$valid} {
        return 0
    }
    #above tests, the input matrix rows=columns
    #test with SR reference matrix sddspseudoinverse.input4 whoserows>columns
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input4 $outFile"  
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0;
    }
    
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddspseudoinverse.output7 -testFile $outFile
    if {!$valid} {
        return 0
    }
    set execute "{$testProgramName} ${inDir}sddspseudoinverse.input6 $outFile" 
    #test with random generated matrix sddspseudoinverse.input6, whose rows (200) <columns (400)
    if [catch {eval exec $execute} results] {
        append finalResults "sddspseudoinverse\n$execute\n$results\n"
        return 0;
    }
    set valid 0
    compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddspseudoinverse.output8 -testFile $outFile
    if {!$valid} {
        return 0
    }
        #test the new option -multiplyMatrix
    #input4 rows>numbers; input6 rows<columns input1 rows=columns
    catch {exec $testProgramName -printPackage} result
    if [regexp LAPACK $result] {
        # -multiplyMatrix only implemented for CLAPACK and LAPACK
        foreach input {input4 input6 input1} {
            set execute "{$testProgramName} ${inDir}sddspseudoinverse.$input -pipe=out -multiplyMatrix=${inDir}sddspseudoinverse.$input \
                -root=doubleColumn -digits=2 | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile"
            set valid 0
            if [catch {eval exec $execute} results] {
                append finalResults "sddspseudoinverse\n$execute\n$results\n"
                return 0
            }
            set execute1 "sddspseudoinverse ${inDir}sddspseudoinverse.$input $outFile.inv"
            if [catch {eval exec $execute1} results] {
                append finalResults "sddspseudoinverse\n$execute1\n$results\n"
                return 0
            }
            set execute2 "sddsmatrixop $outFile.inv -push=${inDir}sddspseudoinverse.$input -multi -pipe=out \
              | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile.op"
            if [catch {eval exec $execute2} results] {
                append finalResults "sddspseudoinverse\n$execute2\n$results\n"
                return 0
            }
            compareOutput -testProgramName $testProgramName -execute $execute \
                -standardFile $outFile.op -testFile $outFile
            if {!$valid} {
                return 0
            }
            #test invert
            set execute "{$testProgramName} ${inDir}sddspseudoinverse.$input -pipe=out -multiplyMatrix=${inDir}sddspseudoinverse.$input,invert \
                -root=doubleColumn -digits=2 | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile"
            set valid 0
            if [catch {eval exec $execute} results] {
                append finalResults "sddspseudoinverse\n$execute\n$results\n"
                return 0
            }
            set execute1 "sddspseudoinverse ${inDir}sddspseudoinverse.$input $outFile.inv"
            if [catch {eval exec $execute1} results] {
                append finalResults "sddspseudoinverse\n$execute1\n$results\n"
                return 0
            }
            set execute2 "sddsmatrixop ${inDir}sddspseudoinverse.$input -push=$outFile.inv -multi -pipe=out \
              | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile.op"
            if [catch {eval exec $execute2} results] {
                append finalResults "sddspseudoinverse\n$execute2\n$results\n"
                return 0
            }
            compareOutput -testProgramName $testProgramName -execute $execute \
                -standardFile $outFile.op -testFile $outFile
            if {!$valid} {
                return 0
            }
        }
    }
    
    optionsPassed -pass {multiplyMatrix}
    return 1
}


proc test_sddsquery {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsprintout.input > $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsquery\n$execute\n$results\n"
    } else {
	if [catch {exec tcomp ${inDir}sddsquery.output $outFile} results] {
	    append finalResults "sddsquery\n$execute\n$results\n"
	} else {
	    set execute "{$testProgramName} ${inDir}sddsprintout.input -columnlist -appendunits -delimiter=& > $outFile"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsquery\n$execute\n$results\n"
	    } else {
		if [catch {exec tcomp ${inDir}sddsquery.output2 $outFile} results] {
		    append finalResults "sddsquery\n$execute\n$results\n"
		} else {
		    optionsPassed -pass {columnlist delimiter}
		    set execute "{$testProgramName} ${inDir}sddsprintout.input -parameterlist -appendunits > $outFile"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddsquery\n$execute\n$results\n"
		    } else {
			if [catch {exec tcomp ${inDir}sddsquery.output3 $outFile} results] {
			    append finalResults "sddsquery\n$execute\n$results\n"
			} else {
			    optionsPassed -pass {parameterlist appendunits}
			    set execute "{$testProgramName} ${inDir}sddsprintout.input -version > $outFile"
			    if [catch {eval exec $execute} results] {
				append finalResults "sddsquery\n$execute\n$results\n"
			    } else {
				if [catch {exec tcomp ${inDir}sddsquery.output4 $outFile} results] {
				    append finalResults "sddsquery\n$execute\n$results\n"
				} else {
				    optionsPassed -pass {version}
				    set execute "{$testProgramName} ${inDir}sddsprintout.input -columnList -sddsOutput=$outFile"
				    if [catch {eval exec $execute} results] {
					append finalResults "sddsquery\n$execute\n$results\n"
				    } else {
					set valid 0
					compareOutput -testProgramName $testProgramName -execute $execute \
					    -standardFile ${inDir}sddsquery.output5 -testFile $outFile
					if {$valid} {
					    optionsPassed -pass {sddsOutput}
					    set returnValue 1
					}
				    }
				}
			    }
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddsregroup {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsprintout.input -pipe=out -newcolumns=Filename -newparameters=string1 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsregroup\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsregroup.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe newcolumns newparameters}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsremoveoffsets {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsremoveoffsets.input | {$testProgramName} -pipe -col=S7A:P2:y -commutationMode=ab2 -fhead=0.3 | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddsremoveoffsets\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsremoveoffsets.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe columns commutationMode fhead}
            set execute "sddsprocess -pipe=out ${inDir}sddsremoveoffsets.input | {$testProgramName} -pipe -col=S7A:P2:y -commutationMode=ab2 -fhead=0.3 -removeCommutationOffset | sddsprocess -pipe=in $outFile"
            if [ catch { eval exec $execute } results ] { 
                append finalResults "sddsremoveoffsets\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsremoveoffsets.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {removeCommutationOffsetOnly}
                    set returnValue 1
                }
            }   	       	 	      		 

        }
    }   	       	 	      		 
    return $returnValue
}

proc test_sddsrowstats {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsrowstats.input.gz -pipe=out -max=GMax,G* -min=GMin,G* -mean=GMean,G* -rms=GRms,G1,G* -stand=GStDev,G1,G2,G3,G4,G5,G6 -sigma=GSigma,G4,G5,G6,G1,G2,G3 -sum=GSum,G1,G2,G3,G* -sum=GSum2,power=2,G*,G1,G2,G3 -sum=GSum4,power=4,G* | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsrowstats\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsrowstats.output -testFile $outFile
      
	if {$valid} {
	    optionsPassed -pass {pipe maximum minimum mean rms standardDeviation sigma sum}
	    set execute "{$testProgramName} ${inDir}sddsrowstats.input2.gz -pipe=out -mean=GRNMean,Column??? -median=GRNMedian,Column??? -mad=GRNMad,Column??? -stand=GRNStDev,Column??? -DRange=GRNDRange,Column??? -qrange=GRNQRange,Column??? -smallest=GRNSmallest,Column??? -largest=GRNLargest,Column??? -min=GRNMin,Column??? -max=GRNMax,Column??? | sddsconvert -pipe=in $outFile -ascii"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsrowstats\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsrowstats.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {median mad drange qrange smallest largest}
		    set execute "{$testProgramName} ${inDir}sddsrowstats.input.gz -max=GMAX,positionColumn=GMAX_Col,G* $outFile"
		    if [catch {eval exec $execute } results] {
		       append finalResults "sddsrowstats\n$execute\n$results\n"
		    } else { 
		       set valid 0
		       compareOutput -testProgramName $testProgramName -execute $execute \
		           -standardFile ${inDir}sddsrowstats.output3 -testFile $outFile
		       if { $valid } {
		          set returnValue 1
		       }
		    }   	  
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddssampledist {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "$testProgramName ${inDir}sddssampledist.input1 $outFile -gaussian=mean=@gaussianMean,sigma=@gaussianSigma,col=gaussian_sample -uniform=col=uniform_sample,min=@minValue,max=@maxValue -poisson=col=pos_sample,mean=@poissonMean -samples=100 -seed=1"
   
    if [catch {eval exec $execute} results] {   
        append finalResults "sddssampledist\n$execute\n$results\n"
        return 0        
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddssampledist.output1 -testFile $outFile
        
        if {$valid} {
            optionsPassed -pass {gaussian poisson uniform seed samples}
            set execute "$testProgramName -gaussian=mean=5.0,sigma=2.0,col=gaussian_sample -uniform=min=1.0,max=10.0,col=uniform_sample -poisson=mean=15,col=pos_sample -pipe=out -samples=100 -seed=1 | sddsprocess -pipe=in $outFile -define=par,gaussianMean,5.0 -define=par,gaussianSigma,2.0 -define=par,meanValue,15.0 -define=par,minValue,1.0 -define=par,maxValue,10.0 -define=par,poissonMean,15.0"
            if [catch {eval exec $execute} results] {
                append finalResults "sddssampledist\n$execute\n$results\n"
                return 0
            } else {
                set valid 0 
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddssampledist.output1 -testFile $outFile  
                if {$valid} {
                    optionsPassed -pass {pipe} 
                    set execute "$testProgramName ${inDir}sddssampledist.input1 $outFile -gaussian=mean=@gaussianMean,sigma=@gaussianSigma,col=gaussian_sample -uniform=col=uniform_sample,min=@minValue,max=@maxValue -poisson=col=pos_sample,mean=@poissonMean -samples=100 -seed=1  -columns=indep=x,cdf=poisson_cdf,output=pos_cdf_x -col=indep=x,df=poisson,output=pos_cdf_x1 -col=indep=x,cdf=poisson_cdf,output=pos_cdf_x2,datafile=${inDir}sddssampledist.input2,factor=2.0,offset=1.5"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddssampledist\n$execute\n$results\n"
                        return 0
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddssampledist.output2 -testFile $outFile 
                        if {$valid} {
                            set execute "$testProgramName ${inDir}sddssampledist.input1 $outFile -col=indep=x,cdf=poisson_cdf,haltonRadix=3,output=pos_x1,haltonOffset=1.5 -samples=100 -seed=1"
                            if [catch {eval exec $execute} results] {
                                append finalResults "sddssampledist\n$execute\n$results\n"
                                return 0
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                    -standardFile ${inDir}sddssampledist.output3 -testFile $outFile 
                                if {$valid} {
                                    set execute "$testProgramName ${inDir}sddssampledist.input1 $outFile  -samples=100 -seed=1  -columns=indep=x,cdf=poisson_cdf,output=pos_cdf_x,rand,group=1 -col=indep=x,df=poisson,output=pos_cdf_x1,rand,group=1 -col=indep=x,cdf=poisson_cdf,output=pos_cdf_x2,datafile=${inDir}sddssampledist.input2,factor=2.0,offset=1.5,rand,group=2 -col=indep=x,cdf=poisson_cdf,haltonRadix=3,rand,group=2"
                                    if [catch {eval exec $execute} results] {
                                        append finalResults "sddssampledist\n$execute\n$results\n"
                                        return 0
                                    } else {
                                        set valid 0
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                            -standardFile ${inDir}sddssampledist.output4 -testFile $outFile 
                                        if {$valid} {
                                            optionsPassed -pass {columns}
                                            set returnValue 1
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return $returnValue
}
 
proc test_sddsselect {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsselect.input -pipe=out | {$testProgramName} -pipe=in ${inDir}sddsselect.input2 -match=name -invert -reuse $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsselect\n$execute\n$results\n"
	return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsselect.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe match invert reuse}
	} else {
	    return 0
	}    
        
    }
    set execute "$testProgramName ${inDir}sddsselect.input3 ${inDir}sddsselect.input3a -equate=particleID $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsselect\n$execute\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsselect.output1 -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {equate}
	    set returnValue 1
	} else {
	    return 0
	}    
       
    }
    return $returnValue
}

proc test_sddsseparate {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsseparate.input | {$testProgramName} -pipe -group=NewName,Phase1,Phase2 | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddsseparate\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsseparate.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe group}
            set execute "sddsprocess -pipe=out ${inDir}sddsseparate.input | {$testProgramName} -pipe -group=NewName,Phase1,Phase2 -copy=Index | sddsprocess -pipe=in $outFile"
            if [ catch { eval exec $execute } results ] { 
                append finalResults "sddsseparate\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsseparate.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {copy}
                    set returnValue 1
                }
            }   	       	 	      		 

        }
    }   	       	 	      		 
    return $returnValue
}

proc test_sddssequence {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} -pipe=out -define=Index,type=long -sequence=begin=30,end=-10,number=30 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddssequence\n$execute\n$results\n"
        set returnValue 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddssequence.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe}
	    set execute "{$testProgramName} -pipe=out -define=Index -sequence=begin=-30,end=10,delta=.50,interval=2 | sddsconvert -pipe=in $outFile -ascii"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddssequence\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddssequence.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {define}
		    set execute "{$testProgramName} -pipe=out -define=Index -sequence=begin=0,delta=1,number=30 | sddsconvert -pipe=in $outFile -ascii"
		    if [catch {eval exec $execute} results] {
			append finalResults "sddssequence\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddssequence.output3 -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {sequence}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddsslopes {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    APSAddToTempFileList ${outFile}4
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsslopes.input.gz -pipe=out | {$testProgramName} -pipe=in $outFile -independentVariable=number -columns=z,Braw,Bcmp,I -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsslopes\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsslopes.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe independentVariable columns ascii}
	    set execute "{$testProgramName} ${inDir}sddsslopes.input.gz -pipe=out -independentVariable=number -excludeColumns=string1 -sigma -residual=${outFile}4 -range=1,71 | sddsconvert -pipe=in $outFile -ascii"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsslopes\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsslopes.output2 -testFile $outFile
		if {$valid} {
		    set valid 0
		    compareOutput -testProgramName $testProgramName -execute $execute \
			-standardFile ${inDir}sddsslopes.residual -testFile ${outFile}4
		    if {$valid} {
			optionsPassed -pass {excludeColumns sigma residual range}
			set returnValue 1
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddssmooth {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddssmooth.input.gz -pipe=out -newColumns -columns=yn -despike=neighbor=5 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddssmooth\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddssmooth.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe newColumns columns despike}
	    set execute "{$testProgramName} ${inDir}sddssmooth.input.gz -pipe=out -points=5 -columns=yn -differenceColumns -passes=2 | sddsconvert -pipe=in $outFile -ascii"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddssmooth\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddssmooth.output2 -testFile $outFile
		if {$valid} {
                    set execute "{$testProgramName} ${inDir}sddssmooth.input.gz -pipe=out -col=y,yn -medianFilter=win=5 | sddsconvert -pipe=in $outFile -ascii"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddssmooth\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddssmooth.output3 -testFile $outFile
                    }
                    if $valid {
                        optionsPassed -pass {points differenceColumns passes medianFilter}
                        set returnValue 1
                    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddssort {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddssort.input.gz -pipe=out -column=RN1,increasing -column=RN2,increasing | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddssort\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddssort.output -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe column}
            set execute "{$testProgramName} ${inDir}sddssort.input.gz -pipe=out -column=RN1,increasing -column=RN2,increasing -unique=count | sddsconvert -pipe=in $outFile -ascii"
            if [catch {eval exec $execute} results] {
                append finalResults "sddssort\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddssort.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {unique}
                    set returnValue 1
                }
            }
        }
    }
    return $returnValue
}

proc test_sddssortcolumn {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddssortcolumn.input -pipe=out -bpmOrder | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddssortcolumn\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddssortcolumn.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe bpmOrder}
            set execute "{$testProgramName} ${inDir}sddssortcolumn.input -pipe=out -sortList=S1C:P0,S1A:P5 | sddsconvert -pipe=in $outFile -ascii"
            if [catch {eval exec $execute} results] {
                append finalResults "sddssortcolumn\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddssortcolumn.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {sortOrder}
                    set execute "{$testProgramName} ${inDir}sddssortcolumn.input -pipe=out -bpmOrder -decreasing | sddsconvert -pipe=in $outFile -ascii"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddssortcolumn\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddssortcolumn.output3 -testFile $outFile
                        if {$valid} {
                            optionsPassed -pass {decreasing}
                            set execute "{$testProgramName} ${inDir}sddssortcolumn.input -pipe=out -bpmOrder -sortWith=${inDir}sddssortcolumn.sort,column=Names | sddsconvert -pipe=in $outFile -ascii"
                            if [catch {eval exec $execute} results] {
                                append finalResults "sddssortcolumn\n$execute\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddssortcolumn.output4 -testFile $outFile
                                if {$valid} {
                                    optionsPassed -pass {sortWith}
                                    set returnValue 1
                                }
                            }

                        }
                    }

                }
            }

        }
    }
    return $returnValue
}

proc test_sddssplit {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    APSAddToTempFileList /tmp/sddssplit.output4 /tmp/sddssplit02.output5 /tmp/sddssplit.output5 /tmp/sddssplit.output6 
    global tcl_platform
    if {$tcl_platform(platform) == "windows"} {
	set prefix "e:"
    } else {
	set prefix ""
    }
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddssplit.input.gz -pipe=out | {$testProgramName} -pipe=in -ascii -nameParameter=string -interval=2"
    if [catch {eval exec $execute} results] {
        append finalResults "sddssplit\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddssplit.output -testFile ${prefix}/tmp/sddssplit.output4
	if {$valid} {
	    set valid 0
	    compareOutput -testProgramName $testProgramName -execute $execute \
		-standardFile ${inDir}sddssplit.output3 -testFile ${prefix}/tmp/sddssplit.output6
	    if {$valid} {
		optionsPassed -pass {pipe ascii nameParameter interval}
		set execute "{$testProgramName} ${inDir}sddssplit.input.gz -binary -digits=2 -rootname=${prefix}/tmp/sddssplit -extension=output5 -firstPage=2 -lastPage=2"
		set execute2 {sddsconvert ${prefix}/tmp/sddssplit02.output5 ${prefix}/tmp/sddssplit.output5 -ascii}
		if [catch {eval exec $execute} results] {
		    append finalResults "sddssplit\n$execute\n$execute2\n$results\n"
		} else {
		    if [catch {eval exec $execute2} results] {
			append finalResults "sddssplit\n$execute\n$execute2\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}sddssplit.output2 -testFile ${prefix}/tmp/sddssplit.output5
			if {$valid} {
			    optionsPassed -pass {binary digits rootname extension firstPage lastPage}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddstdrpeeling {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddstdrpeeling.input | {$testProgramName} -pipe -col=Signal -inputVoltage=1.0 -z0=50 | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddstdrpeeling\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddstdrpeeling.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe column z0}
            set execute "sddsprocess -pipe=out ${inDir}sddstdrpeeling.input | {$testProgramName} -pipe -col=Signal -inputVoltage=@InputVoltage -z0=50 | sddsprocess -pipe=in $outFile"
            if [ catch { eval exec $execute } results ] { 
                append finalResults "sddstdrpeeling\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddstdrpeeling.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {inputVoltage}
                    set returnValue 1
                }
            }   	       	 	      		 

        }
    }   	       	 	      		 
    return $returnValue
}

proc test_sddstimeconvert {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddstimeconvert.input.gz -pipe=out -breakdown=column,Time,year=Year,julianDay=JulianDay,month=Month,day=Day,hour=Hour | {$testProgramName} -pipe -epoch=column,Epoch,year=Year,julianDay=JulianDay,hour=Hour | {$testProgramName} -pipe -epoch=column,Epoch2,year=Year,month=Month,day=Day,hour=Hour | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddstimeconvert\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddstimeconvert.output -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe breakdown epoch}
            set returnValue 1
        }
    }
    return $returnValue
}

proc test_sddstranspose {args} {
    set returnValue 0
    global finalResults
    APSStrictParseArguments {testProgramName inDir outFile}
    #set inDir /home/oxygen/SHANG/test/sddsTest/transpose/
    set execute "$testProgramName ${inDir}sddstranspose.input1 -pipe=out \
                 | sddsprocess -pipe  \
                 -edit=col,magnet,OldColumnNames,azG/%/GB/S/a%/:Horz/A:H3/%/:Vert/A:V3/ \
                 | sddstranspose -pipe=in -newColumnNames=magnet -ascii $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddstranspose\n$execute\n\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddstranspose.output1 -testFile $outFile
        if ${valid} {
            optionsPassed -pass {pipe newColumnNames ascii}
            set execute "$testProgramName ${inDir}sddstranspose.input2 -pipe=out -root=A -digit=3 \
                      | sddscombine -pipe -merge  \
                      | sddstranspose -pipe -root=Prof -digit=3 -symbol=test \
                        -oldColumnName=oldRowName \
                      | sddsconvert -ascii -pipe=in $outFile"
            if [catch {eval exec $execute} results] {
                append finalResults "sddstranspose\n$execute\n\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddstranspose.output2 -testFile $outFile
                if $valid {
                    optionsPassed -pass {root digits oldColumnNames symbol}
                    set execute "$testProgramName ${inDir}sddstranspose.input1 $outFile -matchColumn=S1FB* -matchColumn=S1FB* -indexColumn -noOldColumnNames"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddstranspose\n$execute\n\n$results\n" 
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddstranspose.output3 -testFile $outFile
                        if $valid {
                            optionsPassed -pass {matchColumn indexColumn noOldColumnNames}
                            set returnValue 1
                        }
                    }
                } 
            }
        }
    }
    
    return $returnValue
}

proc test_sddsunwrap {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsunwrap.input | {$testProgramName} -pipe -column=Phase1,Phase2 -threshold=3.14 -modulo=6.2 | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddsunwrap\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsunwrap.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe column threshold modulo}
            set returnValue 1
        }
    }   	       	 	      		 
    return $returnValue
}

proc test_sddsvslopes {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsvslopes.input | {$testProgramName} -pipe -independentVariable=B:bpmT49_56:DelayCount -columns=:ms* -exclude=*.*   | sddsprocess -pipe=in  $outFile "
    if [ catch { eval exec $execute } results ] {
       append finalResults "sddsvslopes\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sddsvslopes.output  -testFile $outFile
        if {$valid} {
            optionsPassed -pass { pipe independentVariable columns excludeColumns }
            set execute "{$testProgramName} ${inDir}sddsvslopes.input $outFile -independentVariable=B:bpmT49_56:DelayCount -columns=:ms* -exclude=*.* -sigma"
            if [ catch { eval exec $execute } results ] {
                append finalResults "sddsvslopes\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                    -standardFile ${inDir}sddsvslopes.output1  -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {sigma}
                    set returnValue 1
                }
            }
        }
    }   	  	     
    return $returnValue
}



proc test_sddsxref {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsxref.input ${inDir}sddsxref.xref -pipe=out -match=RNString=RNString1 -take=RNString1 -transfer=parameter,para1 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsxref\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsxref.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe match take transfer}
	    set execute "{$testProgramName} ${inDir}sddsxref.input ${inDir}sddsxref.xref -pipe=out -nowarnings -equate=RN=RN1 -leave=RNString1 -reuse=rows,page -fillIn | sddsconvert -pipe=in $outFile -ascii"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsxref\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsxref.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {equate leave reuse fillIn nowarnings}
		    set execute "{$testProgramName} ${inDir}sddsxref.input2 ${inDir}sddsxref.xref2 -pipe=out -equate=Time=Time1 -rename=column,Time1=Time1_xref  -edit=column,Value1,ei/_xref/  -transfer=parameter,* -rename=parameter,InputFile1=inputFile1 -edit=parameter,*,ei/_xref/ -transfer=array,* -edit=array,ControlName1,ei/_xref/ -rename=array,DescriptionString1=DescriptionString1_xref | sddsconvert -pipe=in $outFile -ascii"
		    if [ catch { eval exec $execute } results ] {
		       append finalResults "sddsxref\n$execute\n$results\n"
		    } else {
		        set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			   -standardFile ${inDir}sddsxref.output3 -testFile $outFile
			if { $valid } {
			   optionsPassed -pass { rename edit } 
                            #test replace
                            set execute "{$testProgramName} ${inDir}sddsxref.input ${inDir}sddsxref.xref1 -take=RN -replace=col,RN $outFile -nowarnings"
                            if [catch {eval exec $execute} results] {
                                append finalResults "sddsxref\n$execute\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddsxref.output4 -testFile $outFile
                                if {$valid} {
                                    set valid 0
                                    set execute  "{$testProgramName} ${inDir}sddsxref.input ${inDir}sddsxref.xref1 -take=RN -replace=col,RN -equate=I $outFile -nowarnings"
                                    if [catch {eval exec $execute} results] {
                                        append finalResults "sddsxref\n$execute\n$results\n"
                                    } else {
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                          -standardFile ${inDir}sddsxref.output5 -testFile $outFile
                                        if $valid {
                                            optionsPassed -pass { replace }
                                            set returnValue 1
                                        }
                                    }
                                }
                            }
			}
		   }	   
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddszerofind {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddszerofind.input -pipe=out -zeroesOf=J0 -columns=z,J1 -slopeOutput | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddszerofind\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddszerofind.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe}
            set execute "{$testProgramName} ${inDir}sddszerofind.input -pipe=out -zeroesOf=J0 -columns=z,J1 | sddsconvert -pipe=in $outFile -ascii"
            if [catch {eval exec $execute} results] {
                append finalResults "sddszerofind\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddszerofind.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {zeroesOf columns slopeOutput}
                    set execute "{$testProgramName} ${inDir}sddszerofind.input -pipe=out -zeroesOf=J0 -columns=z,J1 -slopeOutput -offset=.1 | sddsconvert -pipe=in $outFile -ascii"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddszerofind\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddszerofind.output3 -testFile $outFile
                        if {$valid} {
                            optionsPassed -pass {pipe zeroesOf columns slopeOutput offset}
                            set returnValue 1
                        }
                    }

                }
            }

        }
    }
    return $returnValue
}

proc test_citi2sdds {args} {
    set returnValue 1
    global finalResults
    APSStrictParseArguments {testProgramName inDir outFile}
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
    
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}csv2sdds.input $outFile -asciiOutput -schFile=${inDir}csv2sdds.sch"
    if [catch {eval exec $execute} results] {
        append finalResults "csv2sdds\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}csv2sdds.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {asciiOutput schFile}
	    set execute "{$testProgramName} ${inDir}csv2sdds.input $outFile -asciiOutput -delimiters=start=\#,end=\# -separator=& -columnData=name=column1,type=double -columnData=name=column2,type=string -columnData=name=column3,type=string -columnData=name=column4,type=double -columnData=name=column5,type=string"
	    if [catch {eval exec $execute} results] {
		append finalResults "csv2sdds\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}csv2sdds.output -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {delimiters separator columnData}
		    set execute "{$testProgramName} ${inDir}csv2sdds.input -pipe=out -asciiOutput -maxRows=4 -schFile=${inDir}csv2sdds.sch | sddsprocess -pipe=in $outFile"
		    if [catch {eval exec $execute} results] {
			append finalResults "csv2sdds\n$execute\n$results\n"
		    } else {
			set valid 0
			compareOutput -testProgramName $testProgramName -execute $execute \
			    -standardFile ${inDir}csv2sdds.output -testFile $outFile
			if {$valid} {
			    optionsPassed -pass {pipe maxRows}
			    set returnValue 1
			} 
		    }
		}
	    }
	}
    }
    return $returnValue

}

proc test_elegant2genesis {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_hpif2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_hpwf2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_image2sdds {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}image2sdds.input  $outFile -2d -ascii  -xdim 256 -ydim 200 "
    if [ catch { eval exec $execute } results ] {
       append finalResults "image2sdds\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}image2sdds.output1  -testFile $outFile
       if {$valid} {
          optionsPassed -pass { 2d ascii xdim ydim}
	  set execute "{$testProgramName} ${inDir}image2sdds.input  $outFile -contour -transpose -xdim 256 -ydim 200 -xmin 1 -xmax 256 -ymin 1 -ymax 200 "
	  if [ catch { eval exec $execute } results ] {
             append finalResults "image2sdds\n$execute\n$results\n"
          } else {
             set valid 0
             compareOutput -testProgramName $testProgramName -execute $execute \
                   -standardFile ${inDir}image2sdds.output2  -testFile $outFile
             if {$valid} {
	        optionsPassed -pass { contour transpose xmin xmax ymin ymax }
		set execute "{$testProgramName} ${inDir}image2sdds.input  $outFile -multicolumnmode -xdim 256 -ydim 200 "
	        if [ catch { eval exec $execute } results ] {
                   append finalResults "image2sdds\n$execute\n$results\n"
                } else {
                   set valid 0
                   compareOutput -testProgramName $testProgramName -execute $execute \
                         -standardFile ${inDir}image2sdds.output3  -testFile $outFile
                   if {$valid} {
		      optionsPassed -pass {multicolumnmode}
	              set returnValue 1
		   }
		}      
             }
	  }   		
       }
    }   	  	     
    return $returnValue
}




proc test_lba2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_mcs2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_mpl2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}



proc test_plaindata2sdds {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}plaindata2sdds.input -pipe=out -inputMode=ascii -outputMode=ascii {-separator=; } -noRowCount -order=rowMajor -parameter=time,string -parameter=fieldIntegral,double -parameter=Isp,double -parameter=Filename,string -parameter=NumberCombined,long -parameter=dummy,string -column=number,long -column=z,double -column=Braw,double -column=Bcmp,double -column=I,double -column=string1,string | sddsprocess -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "plaindata2sdds\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}plaindata2sdds.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe separator noRowCount parameter column}
	    set execute "{$testProgramName} ${inDir}plaindata2sdds.input2 $outFile -inputMode=ascii -outputMode=ascii {-separator= } -order=columnMajor -parameter=time,string -parameter=fieldIntegral,double -parameter=Isp,double -parameter=Filename,string -parameter=NumberCombined,long -parameter=dummy,string -column=number,long -column=z,double -column=Braw,double -column=Bcmp,double -column=I,double -column=string1,string"
	    if [catch {eval exec $execute} results] {
		append finalResults "plaindata2sdds\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}plaindata2sdds.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {order}
		    set returnValue 1
		    if 0 {
			set execute "{$testProgramName} ${inDir}plaindata2sdds.input3 $outFile -inputMode=binary -outputMode=binary -parameter=time,string -parameter=fieldIntegral,double -parameter=Isp,double -parameter=Filename,string -parameter=NumberCombined,long -parameter=dummy,string -column=number,long -column=z,double -column=Braw,double -column=Bcmp,double -column=I,double -column=string1,string"
			if [catch {eval exec $execute} results] {
			    append finalResults "plaindata2sdds\n$execute\n$results\n"
			} else {
			    set valid 0
			    compareOutput -testProgramName $testProgramName -execute $execute \
				-standardFile ${inDir}plaindata2sdds.output3 -testFile $outFile
			    if {$valid} {
				optionsPassed -pass {inputMode outputMode}
				set returnValue 1
			    } 
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}



proc test_raw2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_sdds2mpl {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_sdds2plaindata {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sdds2plaindata.input -pipe=out | {$testProgramName} -pipe=in $outFile -outputMode=ascii -noRowCount -order=rowMajor -parameter=time -parameter=fieldIntegral -parameter=Isp -parameter=Filename -parameter=NumberCombined -parameter=dummy -column=number -column=z -column=Braw -column=Bcmp -column=I -column=string1 {-separator=; } -nowarnings"
    if [catch {eval exec $execute} results] {
        append finalResults "sdds2plaindata\n$execute\n$results\n"
    } else {
	if [catch {exec tcomp ${inDir}sdds2plaindata.output $outFile} results] {
	    append finalResults "sdds2plaindata\n$execute\n$results\n"
	} else {
	    optionsPassed -pass {pipe noRowCount parameter column separator nowarnings}
	    set execute "{$testProgramName} ${inDir}sdds2plaindata.input $outFile -outputMode=ascii -order=columnMajor -parameter=time -parameter=fieldIntegral -parameter=Isp -parameter=Filename -parameter=NumberCombined -parameter=dummy -column=number -column=z -column=Braw -column=Bcmp -column=I -column=string1 -nowarnings {-separator= }"
	    if [catch {eval exec $execute} results] {
		append finalResults "sdds2plaindata\n$execute\n$results\n"
	    } else {
		if [catch {exec tcomp ${inDir}sdds2plaindata.output2 $outFile} results] {
		    append finalResults "sdds2plaindata\n$execute\n$results\n"
		} else {
		    optionsPassed -pass {order}
		    set execute "{$testProgramName} ${inDir}sdds2plaindata.input $outFile -outputMode=binary -parameter=time -parameter=fieldIntegral -parameter=Isp -parameter=Filename -parameter=NumberCombined -parameter=dummy -column=number -column=z -column=Braw -column=Bcmp -column=I -column=string1 -nowarnings"
		    if [catch {eval exec $execute} results] {
			append finalResults "sdds2plaindata\n$execute\n$results\n"
		    } else {
			if [catch {exec tcomp ${inDir}sdds2plaindata.output3 $outFile} results] {
			    append finalResults "sdds2plaindata\n$execute\n$results\n"
			} else {
			    optionsPassed -pass {outputMode}
			    set returnValue 1
			}
		    }
		}
	    }
	}
    }
    return $returnValue
}

proc test_sddsarray2column {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsarray2column.input -pipe=out | {$testProgramName} -pipe=in $outFile -convert=Short,Short -convert=Long,Long -convert=Float,Float -convert=Double,Double -convert=String,String -convert=Char,Char -nowarnings"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsarray2column\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsarray2column.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe convert nowarnings}
	    set returnValue 1
	} 
    }
    return $returnValue
}

proc test_sddsbaseline {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsbaseline.input | {$testProgramName} -pipe -columns=Line* -select=endpoints=10 -method=average -nonnegative -despike=passes=1,widthlimit=4 -repeat=2 | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
       append finalResults "sddsbaseline\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsbaseline.output1 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {pipe columns repeats nonnegative despike }
	  set execute "{$testProgramName} ${inDir}sddsbaseline.input -columns=Line* -select=outsideFWHA=0.1 -method=fit $outFile "
	  if [ catch { eval exec $execute } results ] {
	     append finalResults "sddsbaseline\n$execute\n$results\n"
	  } else {
	     set valid 0
	     compareOutput   -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsbaseline.output2 -testFile $outFile 
	     if {$valid} {
	        optionsPassed -pass { method outsideFWHA }
		set execute "{$testProgramName} ${inDir}sddsbaseline.input -columns=Line* -select=antiOutlier=2 -method=average $outFile "
                if [ catch { eval exec $execute } results ] {
		   append finalResults "sddsbaseline\n$execute\n$results\n"
		} else {
		   set valid 0
		   compareOutput   -testProgramName $testProgramName -execute $execute \
                        -standardFile ${inDir}sddsbaseline.output3 -testFile $outFile  
	           if {$valid } {
		      optionsPassed -pass { antiOutlier select }
		      set returnValue 1
		   }
		}
             }
	  }
       }
    }   	       	 	      		 
    return $returnValue
}

proc test_sddsbinarystring {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}example.sdds | {$testProgramName} -pipe -column=*short*,*long* | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddsbaseline\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsbinarystring.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe columns}
            set returnValue 1
        }
    }   	       	 	      		 
    return $returnValue
}


proc test_sddscliptails {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddscliptails.input | {$testProgramName} -pipe -columns=Line* -fractional=0.02 -absolute=1 | sddsprocess -pipe=in $outFile "
    if [ catch { eval exec $execute} results ] {
       append finalResults "sddscliptails\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddscliptails.output1  -testFile $outFile
       if {$valid} {
          optionsPassed -pass { pipe columns fractional absolute }
	  set execute "{$testProgramName} ${inDir}sddscliptails.input -columns=Line* -fwhm=2 -afterzero=20 $outFile "
	  if [ catch { eval exec $execute} results ] {
             append finalResults "sddscliptails\n$execute\n$results\n"
          } else {
             set valid 0
             compareOutput -testProgramName $testProgramName -execute $execute \
                   -standardFile ${inDir}sddscliptails.output2  -testFile $outFile
             if {$valid} {
                optionsPassed -pass { fwhm afterzero }
		set returnValue 1
             }
	  }
       }
    }      	     		
     return $returnValue
}




proc test_sddsconvolve {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    
    set execute " {$testProgramName} ${inDir}sddsconvolve.input ${inDir}sddsconvolve.input -signalColumns=s,etax -responseColumns=s,betax -outputColumns=s,Conv_betax_etax $outFile "
    if [ catch { eval exec $execute } results ] {
       append finalResults "sddsconvolve\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsconvolve.output1 -testFile $outFile
       if {$valid } {
          optionsPassed -pass { signalColumns responseColumns outputColumns }
	  set execute " {$testProgramName}  ${inDir}sddsconvolve.input  ${inDir}sddsconvolve.output1  $outFile -signalColumns=s,etax   -responseColumns=s,Conv_betax_etax -outputColumns=s,Deconv_betax -noiseFraction=0.1 -deconvolve"
	  if [ catch { eval exec $execute } results ] {
	     append finalResults "sddsconvolve\n$execute\n$results\n"
	  } else {
	     set valid 0
	     compareOutput -testProgramName $testProgramName -execute $execute \
	          -standardFile ${inDir}sddsconvolve.output2 -testFile $outFile
	     if {$valid} {
	        optionsPassed -pass { noiseFraction deconvolve }
		set execute " {$testProgramName}  ${inDir}sddsconvolve.input ${inDir}sddsconvolve.input  $outFile -signalColumns=s,betax -response=s,betay -output=time,xycorrelation -correlate"
		if [ catch { eval exec $execute } results ] {
		   append finalResults "sddsconvolve\n$execute\n$results\n" 
		} else {
		   set valid 0
		   compareOutput -testProgramName $testProgramName -execute $execute \
	                -standardFile ${inDir}sddsconvolve.output3 -testFile $outFile  
	           if {$valid} {
		      optionsPassed -pass {correlate}
		      set returnValue 1
		   }
		}
	     }
	  }
       }
    }
    return $returnValue   	        	      
}


proc test_sddsdistest {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddsdistest.input | {$testProgramName} -pipe -column=*rnd* -test=ks -gaussian -exclude=Ch* | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute} results ] {
       append finalResults "sddsdistest\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsdistest.output1 -testFile $outFile
       if {$valid} {
           optionsPassed -pass { pipe column exclude test gaussian }
	   set execute "{$testProgramName} ${inDir}sddsdistest.input -column=*rnd -test=ks -poisson $outFile"
	   if [ catch { eval exec $execute} results ] {
	      append finalResults sddsdistest\n$execute\n$results\n"
	   } else {
	      set valid 0
	      compareOutput -testProgramName $testProgramName -execute $execute \
                     -standardFile ${inDir}sddsdistest.output2 -testFile $outFile    
	      if {$valid } {
	         optionsPassed -pass { poisson }
		 set execute "{$testProgramName} ${inDir}sddsdistest.input -column=*rnd -test=ks -student -degrees=@degf $outFile"
		 if [ catch { eval exec $execute} results ] {
	            append finalResults sddsdistest\n$execute\n$results\n"
	         } else {
	            set valid 0
	            compareOutput -testProgramName $testProgramName -execute $execute \
                           -standardFile ${inDir}sddsdistest.output3 -testFile $outFile    
	            if {$valid } {
		       optionsPassed -pass { degreesOfFreedom student }
		       set execute "{$testProgramName} ${inDir}sddsdistest.input -column=Chrnd* -test=ks -chisquared -degrees=5 $outFile"
		       if [ catch { eval exec $execute} results ] {
		          append finalResults sddsdistest\n$execute\n$results\n"
		       } else {
		          set valide 0
			  compareOutput -testProgramName $testProgramName -execute $execute \
                                 -standardFile ${inDir}sddsdistest.output4 -testFile $outFile 	  
		          if { $valid } {
			     optionsPassed -pass { chisquared }		 
			     set returnValue 1
			  }
		       }
		    }
		 }
	      }
	   }      	        	     
       }    
    }
    return $returnValue   	   
}  

proc test_sddsduplicate {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}example.sdds | {$testProgramName} -pipe -weight=ushortCol | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddsduplicate\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsduplicate.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe weight}
            set execute "sddsprocess -pipe=out ${inDir}example.sdds | {$testProgramName} -pipe -weight=ushortCol -minFactor=3.3 | sddsprocess -pipe=in $outFile"
            if [ catch { eval exec $execute } results ] { 
                append finalResults "sddsduplicate\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsduplicate.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {minFactor}
                    set execute "sddsprocess -pipe=out ${inDir}example.sdds | {$testProgramName} -pipe -weight=ushortCol -maxFactor=4.4 | sddsprocess -pipe=in $outFile"
                    if [ catch { eval exec $execute } results ] { 
                        append finalResults "sddsduplicate\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddsduplicate.output3 -testFile $outFile
                        if {$valid} {
                            optionsPassed -pass {maxFactor}
                            set execute "sddsprocess -pipe=out ${inDir}example.sdds | {$testProgramName} -pipe -factor=3.6 | sddsprocess -pipe=in $outFile"
                            if [ catch { eval exec $execute } results ] { 
                                append finalResults "sddsduplicate\n$execute\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddsduplicate.output4 -testFile $outFile
                                if {$valid} {
                                    optionsPassed -pass {factor}
                                    set execute "sddsprocess -pipe=out ${inDir}example.sdds | {$testProgramName} -pipe -weight=ushortCol -minFactor=3.3 -probabilistic -seed=4 | sddsprocess -pipe=in $outFile"
                                    if [ catch { eval exec $execute } results ] { 
                                        append finalResults "sddsduplicate\n$execute\n$results\n"
                                    } else {
                                        set valid 0
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                          -standardFile ${inDir}sddsduplicate.output5 -testFile $outFile
                                        if {$valid} {
                                            optionsPassed -pass {probabilistic seed}
                                            set returnValue 1
                                        }
                                    }
                                    
                                }
                            }
                            
                        }
                    }

                }
            }
        }
    }   	       	 	      		 
    return $returnValue
}


proc test_sddsendian {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsendian.input -pipe=out | {$testProgramName} -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsendian\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsendian.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe}
	    set execute "{$testProgramName} ${inDir}sddsendian.output $outFile -nonNative"
	    if [catch {eval exec $execute} results] {
		append finalResults "sddsendian\n$execute\n$results\n"
	    } else {
		set valid 0
		compareOutput -testProgramName $testProgramName -execute $execute \
		    -standardFile ${inDir}sddsendian.output2 -testFile $outFile
		if {$valid} {
		    optionsPassed -pass {nonNative}
		    set returnValue 1
		} 
	    }
	} 
    }
    return $returnValue
}

proc test_sddseventhist { args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddseventhist.input | {$testProgramName} -pipe -data=gap -event=SectorName -bins=50 -normalize | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] {
       append finalResults "sddseventhist\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddseventhist.output1 -testFile $outFile
       if { $valid } {
          optionsPassed -pass { pipe dataColumn eventIdentifier bins }
	  set execute " {$testProgramName} ${inDir}sddseventhist.input -data=gap -event=SectorName -sizeOfBins=10 -lowerLimit=20 -upperLimit=160  -normalize=area $outFile"
	  if [ catch { eval exec $execute } results ] {
             append finalResults "sddseventhist\n$execute\n$results\n"
          } else {
             set valid 0
             compareOutput -testProgramName $testProgramName -execute $execute \
                    -standardFile ${inDir}sddseventhist.output2 -testFile $outFile
             if { $valid } {
                 optionsPassed -pass { sizeOfBins lowerLimit upperLimit}
	         set execute "{$testProgramName} ${inDir}sddseventhist.input -data=gap -event=SectorName -bins=10 -sides -overlapEvent=Sector8  -normalize=peak $outFile"
	         if [ catch { eval exec $execute } results ] {
                    append finalResults "sddseventhist\n$execute\n$results\n"
                 } else {
                    set valid 0
                    compareOutput -testProgramName $testProgramName -execute $execute \
                           -standardFile ${inDir}sddseventhist.output3 -testFile $outFile
                    if { $valid } {
                        optionsPassed -pass {sides normalize overlapEvent} 
	                set returnValue 1
	            }
		}
	     }
	  }      	    		
       }   
    }
    return $returnValue   
}

proc test_sddsexpand {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsexpand.input -pipe=out | {$testProgramName} -pipe=in $outFile -noWarnings"
    if [catch {eval exec $execute} results] {
	append finalResults "sddsexpand\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsexpand.output -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe noWarnings}
	    set returnValue 1
	}
    }
    return $returnValue
}

proc test_sddsgenericfit { args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddsgenericfit.input | {$testProgramName} -pipe -column=x,y,ySigma=err {-equation= x sqr a *  x 3 pow 0.2 * 1 + / }  -variable=name=a,start=0,lower=-10,upper=100,step=1  -target=0.00001 -tolerance=0.00001  -simplex=restart=20,cycles=12,evaluations=6000 -startFromPrevious | sddsconvert -pipe=in -ascii $outFile "
    if [ catch { eval exec $execute} results ] {
       append finalResults "sddsgenericfit\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsgenericfit.output  -testFile $outFile
       if {$valid } {
           set execute "{$testProgramName} ${inDir}sddsgenericfit.input2  -column=x,y {-equation=H x C - sqr 2 / S sqr / exp / B +  } -variable=name=H,start=70,lower=50,upper=150,step=1 -variable=name=C,start=20,lower=0,upper=50,step=0.1  -variable=name=S,start=1,lower=0,upper=10,step=0.1 -variable=name=B,start=1,lower=0,upper=10.,step=0.1 $outFile"
	   if [ catch { eval exec $execute} results ] {
	      append finalResults "sddsgenericfit\n$execute\n$results\n"
	   } else {
	      set valid 0
	      compareOutput -testProgramName $testProgramName -execute $execute \
	             -standardFile ${inDir}sddsgenericfit.ouput2 -testFile $outFile
	      if {$valid } {
	         set execute "${testProgramName} ${inDir}sddsgenericfit.input3 -column=x,y {-equation= c x a - chs  b / exp * d +  } -variable=name=a,start=20,lower=15,upper=30,step=.1 -variable=name=b,start=10,lower=0,upper=100,step=1 -variable=name=c,start=5,lower=1,upper=10,step=1 -variable=name=d,start=10,lower=0,upper=200,step=1  $outFile"
		 if [ catch { eval exec $execute} results ] {
	            append finalResults "sddsgenericfit\n$execute\n$results\n"
	         } else {
	            set valid 0
	            compareOutput -testProgramName $testProgramName -execute $execute \
	                   -standardFile ${inDir}sddsgenericfit.ouput3 -testFile $outFile 	        
	            if {$valid } {    
                       optionsPassed -pass { pipe columns equation variable target tolerance simplex startFromPrevious }
		       set returnValue 1
		    }   
		 }
	      }	    
	   }   
       }
    }
    return $returnValue   	   
}     
    


proc test_sddsimageprofiles {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsimageprofiles.input | {$testProgramName} -pipe -columnPrefix=Line -profileType=x  | sddsprocess -pipe=in $outFile "
    if [catch {eval exec $execute} results] {
        append finalResults "sddsimageprofiles\n$execute\n$results\n"
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsimageprofiles.output1 -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe columnPrefix}
	    set execute "{$testProgramName} ${inDir}sddsimageprofiles.input2 -profileType=y -columnPrefix=Line -method=average $outFile "
	    if [catch {eval exec $execute} results] {
               append finalResults "sddsimageprofiles\n$execute\n$results\n"
            } else {
	       set valid 0
	       compareOutput -testProgramName $testProgramName -execute $execute \
	            -standardFile ${inDir}sddsimageprofiles.output2 -testFile $outFile
	       if {$valid} {
	          optionsPassed -pass {profileType}
		  set execute "{$testProgramName} ${inDir}sddsimageprofiles.input -method=integrated -columnPrefix=Line $outFile "
		  if [catch {eval exec $execute} results] {
                     append finalResults "sddsimageprofiles\n$execute\n$results\n"
                  } else {
	             set valid 0
	             compareOutput -testProgramName $testProgramName -execute $execute \
	                   -standardFile ${inDir}sddsimageprofiles.output3 -testFile $outFile
	             if {$valid} {
	                set execute "{$testProgramName} ${inDir}sddsimageprofiles.input -columnPrefix=Line -method=centerLine $outFile "
		        if [catch {eval exec $execute} results] {
                           append finalResults "sddsimageprofiles\n$execute\n$results\n"
                        } else {
	                   set valid 0
	                   compareOutput -testProgramName $testProgramName -execute $execute \
	                         -standardFile ${inDir}sddsimageprofiles.output4 -testFile $outFile
	                  if {$valid} {    
			     optionsPassed -pass {method}
			     set execute "{$testProgramName} ${inDir}sddsimageprofiles.input -columnPrefix=Line -method=peak  -background=${inDir}sddsimageprofiles.input3 $outFile "
		             if [catch {eval exec $execute} results] {
                                append finalResults "sddsimageprofiles\n$execute\n$results\n"
                             } else {
	                        set valid 0
	                        compareOutput -testProgramName $testProgramName -execute $execute \
	                              -standardFile ${inDir}sddsimageprofiles.output5 -testFile $outFile
	                        if {$valid} {
				   optionsPassed -pass {method background}
			           set returnValue 1
				}
		             }
			  }   	
		       }
		    }
		 }
	      }   	          	  	   
	    }
	} 
    }
    return $returnValue
}

proc test_sddsinsideboundaries {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsinsideboundaries.input | {$testProgramName} -pipe -columns=x,y -boundary=${inDir}sddsinsideboundaries.boundary.sdds,x_boundary,y_boundary -keep=inside | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] { 
        append finalResults "sddsinsideboundaries\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsinsideboundaries.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe columns boundary}
            set execute "sddsprocess -pipe=out ${inDir}sddsinsideboundaries.input | {$testProgramName} -pipe -columns=x,y -boundary=${inDir}sddsinsideboundaries.boundary.sdds,x_boundary,y_boundary -keep=outside | sddsprocess -pipe=in $outFile"
            if [ catch { eval exec $execute } results ] { 
                append finalResults "sddsinsideboundaries\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsinsideboundaries.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {keep}
                    set execute "sddsprocess -pipe=out ${inDir}sddsinsideboundaries.input | {$testProgramName} -pipe -columns=x,y -boundary=${inDir}sddsinsideboundaries.boundary.sdds,x_boundary,y_boundary -keep=outside -threads=3 -insideColumn=insideSum | sddsprocess -pipe=in $outFile"
                    if [ catch { eval exec $execute } results ] { 
                        append finalResults "sddsinsideboundaries\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddsinsideboundaries.output3 -testFile $outFile
                        if {$valid} {
                            optionsPassed -pass {threads insideColumn}
                            set returnValue 1
                        }
                    }   	       	 	      		 

                }
            }   	       	 	      		 

        }
    }   	       	 	      		 
    return $returnValue
}


proc test_sddsmatrix2column {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsmatrix2column.input -pipe=out | ${testProgramName} -pipe -rowNameColumn=RowName | sddsprocess -pipe=in $outFile "
    if [ catch {eval exec $execute } results ] {
        append finalResults "sddsmatrix2column\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmatrix2column.output1 -testFile $outFile  
        if {$valid} {
            optionsPassed -pass {pipe rowNameColumn }
            set execute "${testProgramName} ${inDir}sddsmatrix2column.input $outFile -rowNameColumn=RowName -dataColumnName=Val  "
            if [ catch {eval exec $execute } results ] {
                append finalResults "sddsmatrix2column\n$execute\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsmatrix2column.output2 -testFile $outFile  
                if {$valid} {
                    optionsPassed -pass { dataColumnName }
                    set execute "${testProgramName} ${inDir}sddsmatrix2column.input $outFile -rowNameColumn=RowName -rootnameColumnName=One "
                    if [ catch {eval exec $execute } results ] {
                        append finalResults "sddsmatrix2column\n$execute\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddsmatrix2column.output3 -testFile $outFile  
                        if {$valid} {
                            optionsPassed -pass { rootnameColumnName }
                            set returnValue 1
                        }
                    }   	     

                }
            }   	     

        }
    }   	     
    return $returnValue
}

proc test_sddsmatrixmult {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsmatrixmult.input3 -pipe=out | ${testProgramName} -pipe=in,out -commute ${inDir}sddsmatrixmult.input -reuse | ${testProgramName} -pipe=in ${inDir}sddsmatrixmult.input2 -reuse -ascii $outFile "
    if [ catch {eval exec $execute } results ] {
        append finalResults "sddsmatrixmult\n$execute\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmatrixmult.output -testFile $outFile  
        if {$valid} {
            optionsPassed -pass {pipe commute reuse ascii }
            set returnValue 1
        }
    }   	     
    return $returnValue
}

proc test_sddsmatrixop {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    global finalResults
    set returnValue 1
    set execute "{$testProgramName} ${inDir}sddsmatrixop.input1 -pipe=out \
        -push=${inDir}sddsmatrixop.input1 -add -push=${inDir}sddsmatrixop.input1 \
        -scalarmultiply=2.0 -sub \
        | sddsconvert -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        set returnValue 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmatrixop.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {push add substract scalarmultiply}
        } else {
            return 0;
        }
    }
    set execute "{$testProgramName} ${inDir}sddsmatrixop.input1 -pipe=out \
        -push=${inDir}sddsmatrixop.input1 -add -push=${inDir}sddsmatrixop.input1 \
        -scalardivide=0.5 -sub \
        | sddsconvert -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        set returnValue 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmatrixop.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {scalardivide}
        } else {
            return 0;
        }
    }
    set execute "{$testProgramName} ${inDir}sddsmatrixop.input1 -pipe=out \
                 -push=${inDir}sddsmatrixop.input2 -mult=hadamard \
                 -push=${inDir}sddsmatrixop.input1 -push=${inDir}sddsmatrixop.input2 \
                 -mult=hadamard \
                 -divide=hadamard -identity -sub | sddsconvert -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        set returnValue 0
    } else {
	set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
        -standardFile ${inDir}sddsmatrixop.output2 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {multiply=hadamard divide=hadamard}
        } else {
            return 0;
        }
    }
    set execute "{$testProgramName} ${inDir}sddsmatrixop.origmatrix \
                 -push=${inDir}sddsmatrixop.origmatrix \
                 -invert -mult -identity=4 -sub -pipe=out \
                | sddsconvert -pipe=in $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        set returnValue 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmatrixop.output3 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {identity=<number> }
        } else {
            return 0;
        }
    }
    set execute "{$testProgramName} ${inDir}sddsmatrixop.input3 \
                -push=${inDir}sddsmatrixop.input3 \
                -swap -transpose -mult -identity -add -invert \
                -push=${inDir}sddsmatrixop.input3 -push=${inDir}sddsmatrixop.input3 \
                -swap -transpose -mult -identity -add -mult -identity -sub -pipe=out \
                -columnNames=file=${inDir}sddsmatrixop.columnNames,column=ColumnName \
               | sddsconvert -pipe=in -ascii $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        set returnValue 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sddsmatrixop.output4 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {identity swap transpose columnNames}
        } else {
            return 0;
        }
    }
    
    #square matrix
    set execute "{$testProgramName} ${inDir}squareMatrix -push=${inDir}squareMatrix -multiply $outFile "
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}squareMatrix.output -testFile $outFile
        if {!$valid} {
            return 0
        }
    }
    
    #rect matrix
    set execute "{$testProgramName} ${inDir}rectMatrix1 -push=${inDir}rectMatrix2 -multiply $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}rectMatrix1.output -testFile $outFile
        if {!$valid} {
            return 0
        }
    }
    set execute "{$testProgramName} ${inDir}rectMatrix2 -push=${inDir}rectMatrix1 -multiply $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}rectMatrix2.output -testFile $outFile
        if {!$valid} {
            return 0
        }
    }
    optionsPassed -pass {multiply}
    set execute "sddsprocess ${inDir}sddsmatrixop.input4 -pipe=out -def=col,Unity,1 \
                 | sddsconvert -pipe -retain=col,Unity \
                 | {$testProgramName} -pipe -push=${inDir}sddsmatrixop.input4 -swap \
                 -mult | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmatrixop\n$execute\n$results\n"
        set returnValue 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmatrixop.output5 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe}
        } else {
            return 0;
        }
    }
    catch {exec $testProgramName -printPackage} result
  
    if [regexp {LAPACK} $result] {
        #test the inverse of square and rectangular matrices
        foreach nm {square rect1 rect2} {
            set execute1 "sddspseudoinverse ${inDir}${nm}Matrix -root=doubleColumn -digits=3 -pipe=out \
             | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile.inv1"
            set execute2 "$testProgramName  ${inDir}${nm}Matrix -pipe=out -digits=3 -invert  \
             | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile.inv2"
            if [catch {eval exec $execute1} results] {
                append finalResults "sddsmatrixop\n$execute1\n$results\n"
                return 0
            }
            if [catch {eval exec $execute2} results] {
                append finalResults "sddsmatrixop\n$execute2\n$results\n"
                return 0
            }
            set valid 0
            compareOutput -testProgramName $testProgramName -execute $execute \
                -standardFile $outFile.inv1 -testFile $outFile.inv2
            if !$valid {
                return 0
            }
            foreach option {largest=32 smallest=10 minimum=0.1} {
                set execute1 "sddspseudoinverse ${inDir}${nm}Matrix -root=doubleColumn -digits=3 -pipe=out -$option \
                     | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile.inv1"
                set execute2 "$testProgramName -pipe=out -digits=3 ${inDir}${nm}Matrix -invert=$option \
                 | sddsconvert -pipe=in -del=par,* -del=array,* -retain=col,doubleColumn* $outFile.inv2"
                if [catch {eval exec $execute1} results] {
                    append finalResults "sddsmatrixop\n$execute1\n$results\n"
                    return 0
                }
                if [catch {eval exec $execute2} results] {
                    append finalResults "sddsmatrixop\n$execute2\n$results\n"
                    return 0
                }
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                    -standardFile $outFile.inv1 -testFile $outFile.inv2
                if !$valid {
                    return 0
                }
            }
        }
        #optionsPassed -pass {invert}
    }
    optionsPassed -pass {invert}
    return $returnValue
}

proc test_sddsminterp { args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddsminterp.input | {$testProgramName}  -pipe  -columns=samx,pdbs -order=3 -model=${inDir}sddsminterp.model,abscissa=samx,ordinate=pdbs,interp=3 | sddsprocess -pipe=in $outFile"
    if [ catch { eval exec $execute } results ] {
       append finalResults "sddsminterp\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsminterp.output1 -testFile $outFile
       if { $valid } {
          optionsPassed -pass { pipe columns order model }
	  set execute " {$testProgramName} ${inDir}sddsminterp.input -columns=samx,torque  -ascii -model=${inDir}sddsminterp.model,abscissa=samx,ordinate=torque  $outFile"
	  if [ catch { eval exec $execute } results ] {
             append finalResults "sddsminterp\n$execute\n$results\n"
          } else {
             set valid 0
             compareOutput -testProgramName $testProgramName -execute $execute \
                    -standardFile ${inDir}sddsminterp.output2 -testFile $outFile
             if { $valid } {
                 optionsPassed -pass { ascii }
	         set returnValue 1
	     }
	 }      	    		
       }   
    }
    return $returnValue   
}

proc test_sddsmselect {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsmselect.input -pipe=out | {$testProgramName} -pipe ${inDir}sddsmselect.input2 -match=name -invert -reuse | sddsprocess -pipe=in  $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmselect\n$execute\n$results\n"
	return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	    -standardFile ${inDir}sddsmselect.output1 -testFile $outFile
	if {$valid} {
	    optionsPassed -pass {pipe match invert reuse}
	} else {
	    return 0
	}    
       
    }
    set execute "$testProgramName ${inDir}sddsmselect.input3 ${inDir}sddsmselect.input3a  -equate=xp -equate=particleID $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmselect\n$execute\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
	       -standardFile ${inDir}sddsmselect.output2 -testFile $outFile
	if {$valid} {
	   optionsPassed -pass {equate}
	   set returnValue 1
	} else {
           return 0
	}   
    }
    return $returnValue
}




proc test_sddsmxref {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} ${inDir}sddsmxref.input ${inDir}sddsmxref.xref -pipe=out -match=RNString=RNString1 -take=RNString1 -transfer=parameter,para1 | sddsconvert -pipe=in $outFile -ascii"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsmxref\n$execute\n\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsmxref.output1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe take transfer}
            set execute "{$testProgramName} ${inDir}sddsmxref.input ${inDir}sddsmxref.xref -pipe=out -nowarnings -equate=RN=RN1 -leave=RNString1 -reuse=rows,page -fillIn | sddsconvert -pipe=in $outFile -ascii"
            if [catch {eval exec $execute} results] {
                append finalResults "sddsmxref\n$execute\n\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                  -standardFile ${inDir}sddsmxref.output2 -testFile $outFile
                if {$valid} {
                    optionsPassed -pass {nowarnings leave reuse fillIn}
                    set execute "{$testProgramName} ${inDir}sddsmxref.input1 ${inDir}sddsmxref.xref1 -pipe=out -match=RowLabel -take=* -transfer=par,* -rename=column,Index=Index2,RowLabel=RowLabel2 -rename=par,Page=Page2 | sddsconvert -pipe=in $outFile"
                    if [catch {eval exec $execute} results] {
                        append finalResults "sddsmxref\n$execute\n\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute \
                          -standardFile ${inDir}sddsmxref.output3 -testFile $outFile
                        if {$valid} {
                            optionsPassed -pass {rename}
                            set execute "{$testProgramName} ${inDir}sddsmxref.input1 ${inDir}sddsmxref.xref1 -pipe=out -match=RowLabel -take=* -transfer=par,* -editnames=column,*,ei/2/ -editnames=parameter,*,ei/2/ | sddsconvert -pipe=in $outFile"
                            if [catch {eval exec $execute} results] {
                                append finalResults "sddsmxref\n$execute\n\n$results\n"
                            } else {
                                set valid 0
                                compareOutput -testProgramName $testProgramName -execute $execute \
                                  -standardFile ${inDir}sddsmxref.output4 -testFile $outFile
                                if {$valid} {
                                    optionsPassed -pass {edit transfer}
                                    #test multiple match and equate options
                                    set execute "$testProgramName ${inDir}sddsmxref.input1 ${inDir}sddsmxref.xref1 -pipe=out -match=RowLabel -equate=Index -nowarnings | sddsconvert -pipe=in $outFile -ascii"
                                    if [catch {eval exec $execute} results] {
                                        append finalResults "sddsmxref\n$execute\n\n$results\n"
                                    } else {
                                        set valid 0
                                        compareOutput -testProgramName $testProgramName -execute $execute \
                                          -standardFile ${inDir}sddsmxref.output5 -testFile $outFile
                                        if {$valid} {
                                            set execute "$testProgramName ${inDir}sddsmxref.input2 ${inDir}sddsmxref.xref2 -pipe=out -match=RowLabel,RNString=RNString1 -nowarnings -equate=Index,RN=RN1 -ifis=col,RN,Index -ifnot=par,Page1 | sddsconvert -pipe=in $outFile -ascii"
                                            if [catch {eval exec $execute} results] {
                                                append finalResults "sddsmxref\n$execute\n\n$results\n"
                                            } else {
                                                set valid 0
                                                compareOutput -testProgramName $testProgramName -execute $execute \
                                                  -standardFile ${inDir}sddsmxref.output6 -testFile $outFile
                                                if {$valid} {
                                                    optionsPassed -pass {match equate ifis ifnot}
                                                    set returnValue 1
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return $returnValue
}

proc test_sddsnaff {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 1
    global finalResults
    
    set execute "{$testProgramName} ${inDir}sddsnaff.input1 $outFile -column=x,A,B -terminate=maxfreq=6,changelimit=.025"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsnaff\n$execute\n\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsnaff.out1 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {column terminateSearch}
        } else {
            return 0
        }
    }
    set execute "{$testProgramName} ${inDir}sddsnaff.input2 $outFile -column=x,A,B -terminate=maxfreq=6,changelimit=.025 -truncate"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsnaff\n$execute\n\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsnaff.out2 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {truncate}
        } else {
            return 0
        }
    }
    set execute "sddsconvert ${inDir}sddsnaff.input3 -pipe=out -rename=col,C=A1,D=B1 | $testProgramName -pipe=in   -col=x,A*,B* -exclude=*1 $outFile"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsnaff\n$execute\n\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsnaff.out3 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pipe exclude}
        } else {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sddsnaff.input3 $outFile -col=x -pair=A,B -pair=C,D -terminate=maxfreq=6,changelimit=.025"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsnaff\n$execute\n\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsnaff.out4 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {pair}
        } else {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sddsnaff.input3 $outFile -col=x,A,B -iterateFrequency=cycle=10,accuracy=0.001"
    if [catch {eval exec $execute} results] {
        append finalResults "sddsnaff\n$execute\n\n$results\n"
        return 0
    } else {
	set valid 0
	compareOutput -testProgramName $testProgramName -execute $execute \
          -standardFile ${inDir}sddsnaff.out5 -testFile $outFile
        if {$valid} {
            optionsPassed -pass {iterateFrequency}
        } else {
            return 0
        }
    }
    return 1
}

proc test_sddsnormalize {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess ${inDir}sddsnormalize.input -pipe=out | {$testProgramName} -pipe -columns=mode=maximum,suffix=.Norm,exclude=*60m,Temperature*,WindSpeed* -columns=mode=minimum,Barometic*  -columns=mode=largest,BatteryVoltage -columns=mode=signedLargest,suffix=_Norm,NetRadiation -columns=mode=spread,suffix=_Norm,GlobalIrradiation | sddsprocess -pipe=in $outFile "
    if [ catch {eval exec $execute} results ] {
       append finalResults "sddsnormalize\n$execute\n\n$results\n"
    } else { 
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsnormalize.output1 -testFile $outFile
       if {$valid} {
          optionsPassed -pass {pipe columns}
          set returnValue 1
       }
    }   	  	  	        
    return $returnValue
}


proc test_sddsrunstats {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults 
    set execute "sddscombine ${inDir}sddsrunstats.input ${inDir}sddsrunstats.input -pipe=out | ${testProgramName} -pipe  -points=100 -partialOk -mean=Time,P1P?x -min=P1P?x -max=P1P?x -sigma=P1P?x -standardDeviation=P1P?x | sddsconvert -pipe=in -ascii $outFile"
    if [ catch { eval exec $execute } results ] {
        append finalResults "sddsrunstats\n$execute\n\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute  -standardFile ${inDir}sddsrunstats.output1 -testFile $outFile
        if {$valid } {
            optionsPassed -pass { pipe points partialOk mean minimum maximum sigma standardDeviation }
            set execute "${testProgramName} ${inDir}sddsrunstats.input -window=column=Time,width=120 -noOverlap {-max=P1P4x} {-min=P1P4x} {-sum=topLimit=1,bottomLimit=-1.5,P1P4x} -sample=Time  $outFile"
            if [ catch {eval exec $execute } results ] {
                append finalResults "sddsrunstats\n$execute\n\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute  -standardFile ${inDir}sddsrunstats.output2 -testFile $outFile
                if {$valid } {
                    optionsPassed -pass { window sample sum noOverlap }
                    
                    set execute "${testProgramName} ${inDir}sddsrunstats.input $outFile -window=column=Time,width=120 -noOverlap -max=P1P4x -min=P1P4x -sum=topLimit=1,bottomLimit=-1.5,P1P4x -sample=Time -median=P1P1x,P1P2x -median=topLimit=1,bottomLimit=-1.5,P1P4x"
                    if [catch {eval exec $execute} results] {
                         append finalResults "sddsrunstats\n$execute\n\n$results\n"
                    } else {
                        set vaild 0  
                        compareOutput -testProgramName $testProgramName -execute $execute  -standardFile ${inDir}sddsrunstats.output3 -testFile $outFile
                        if {$valid } {
                            optionsPassed -pass {median}
                            set returnValue 1
                        }
                    }
                }
            }   
        }
        
    }    	  
    
    return $returnValue
}

proc test_sddsshift {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}example.sdds | ${testProgramName} -pipe=in,out -col=shortCol,doubleCol -shift=1 | sddsprocess -pipe=in $outFile"
    if [ catch {eval exec $execute} results ] {
        append  finalResults "sddsshift\n$execute\n\n$results\n"
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute  -standardFile ${inDir}sddsshift.output1 -testFile $outFile
        if {$valid } {
            optionsPassed -pass { pipe columns shift }
            set execute "sddsprocess -pipe=out ${inDir}example.sdds | ${testProgramName} -pipe=in,out -col=shortCol,doubleCol -shift=1 -zero | sddsprocess -pipe=in $outFile"
            if [ catch {eval exec $execute} results ] {
                append  finalResults "sddsshift\n$execute\n\n$results\n"
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute  -standardFile ${inDir}sddsshift.output2 -testFile $outFile
                if {$valid } {
                    optionsPassed -pass { zero }
                    set execute "sddsprocess -pipe=out ${inDir}example.sdds | ${testProgramName} -pipe=in,out -col=shortCol,doubleCol -shift=1 -circular | sddsprocess -pipe=in $outFile"
                    if [ catch {eval exec $execute} results ] {
                        append  finalResults "sddsshift\n$execute\n\n$results\n"
                    } else {
                        set valid 0
                        compareOutput -testProgramName $testProgramName -execute $execute  -standardFile ${inDir}sddsshift.output3 -testFile $outFile
                        if {$valid } {
                            optionsPassed -pass { circular }
                            set returnValue 1
                        }
                    }

                }
            }

        }
    }
    return $returnValue
}

proc test_sddsshiftcor {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "sddsprocess -pipe=out ${inDir}sddsshiftcor.input | {$testProgramName} -pipe -with=:sum.RVAL -scan=start=-20,end=10,delta=1  -columns=:ms* -exclude=:ms.* -stDevOutlier=passes=2 | sddsprocess -pipe=in  $outFile "
    if [ catch { eval exec $execute } results ] {
       append finalResults "sddsshiftcor\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsshiftcor.output1  -testFile $outFile
       if {$valid} {
          optionsPassed -pass { pipe with scan  columns excludeColumns stDevOutlier }
	  set execute "{$testProgramName} ${inDir}sddsshiftcor.input -with=:ms:x -columns=:ms:y -rankOrder $outFile"
	  if [ catch { eval exec $execute } results ] {
             append finalResults "sddsshiftcor\n$execute\n$results\n"
          } else {
             set valid 0
	     compareOutput -testProgramName $testProgramName -execute $execute \
                   -standardFile ${inDir}sddsshiftcor.output2  -testFile $outFile
             if {$valid} {
	        optionsPassed -pass { rankOrder}
	        set returnValue 1
	     }
	  }   	
       }
    }   	  	     
    return $returnValue
}


proc test_sddssinefit {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddssinefit.input | {$testProgramName} -pipe -columns=x,y  -fulloutput -tolerance=0.001  | sddsprocess -pipe=in $outFile "
    if [ catch { eval exec $execute} results ] {
       append finalResults "sddssinefit\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddssinefit.output1  -testFile $outFile
       if {$valid} {
          optionsPassed -pass { pipe columns fulloutput tolerance }
	  set execute "{$testProgramName} ${inDir}sddssinefit.input -columns=x,y -limits=evaluations=200,passes=5 -guess=constant=1,factor=2,frequency=1,phase=1 $outFile "
	  if [ catch { eval exec $execute} results ] {
             append finalResults "sddssinefit\n$execute\n$results\n"
          } else {
             set valid 0
             compareOutput -testProgramName $testProgramName -execute $execute \
                   -standardFile ${inDir}sddssinefit.output2  -testFile $outFile
             if {$valid} {
                optionsPassed -pass { limits guess }
		set returnValue 1
             }
	  }
       }
    }      	     		
     return $returnValue
}

proc test_sddsspotanalysis {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute " sddsprocess -pipe=out ${inDir}sddsspotanalysis.input1 | {$testProgramName} -pipe -imageColumn=Image* -levels=intensity=256,saturation=200 -centerOn=xcentroid,ypeak -ROI=x0value=30,x1value=170,y0value=50,y1value=150  -spotROIsize=xvalue=50,yvalue=50 -spotImage=${outFile}_1 | sddsprocess -pipe=in  $outFile"
    if [ catch { eval exec $execute } results ] {
       append finalResults "sddsspotanalysis\n$execute\n$results\n"
    } else {
       set valid 0
       compareOutput -testProgramName $testProgramName -execute $execute \
             -standardFile ${inDir}sddsspotanalysis.output1 -testFile $outFile
       if { $valid } {
          set valid 0
	  compareOutput -testProgramName $testProgramName -execute $execute \
	         -standardFile ${inDir}sddsspotanalysis.spotImage1 -testFile ${outFile}_1
	  if { $valid } {	 
             optionsPassed -pass { pipe imageColumns ROI spotROIsize centerOn spotImage levels }
	     set execute " {$testProgramName} ${inDir}sddsspotanalysis.input2 -imageColumn=Image* -sizeLines=xvalue=5,yvalue=5 -singleSpot -background=halfwidth=5,symmetric,antihalo,antiloner -ROI=x0parameter=r1x0,x1parameter=r1x1,y0parameter=r1y0,y1parameter=r1y1 -despike=neighbors=6,passes=2,averageOf=3 -spotImage=${outFile}_2  $outFile"
	     if [ catch { eval exec $execute } results ] {
	        append finalResults "sddsspotanalysis\n$execute\n$results\n"
	     } else {
	        set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                       -standardFile ${inDir}sddsspotanalysis.output2 -testFile $outFile
		if {$valid} {
		   set valid 0
	           compareOutput -testProgramName $testProgramName -execute $execute \
	                 -standardFile ${inDir}sddsspotanalysis.spotImage2 -testFile ${outFile}_2
		   if { $valid } {
	              optionsPassed -pass { background despike singleSpot  sizeLines }
		      set execute "{$testProgramName} ${inDir}sddsspotanalysis.input2 -imageColumn=Image* -blankOut=x0parameter=cx0,x1parameter=cx1,y0parameter=cy0,y1parameter=cy1 -background=halfwidth=0,antihalo -spotImage=${outFile}_3 $outFile"
		      if [ catch { eval exec $execute } results ] {
	                 append finalResults "sddsspotanalysis\n$execute\n$results\n"
	              } else {
	                 set valid 0
                         compareOutput -testProgramName $testProgramName -execute $execute \
                                -standardFile ${inDir}sddsspotanalysis.output3 -testFile $outFile
                         if { $valid } {
			    set vlid 0
			    compareOutput -testProgramName $testProgramName -execute $execute \
	                          -standardFile ${inDir}sddsspotanalysis.spotImage3 -testFile ${outFile}_3
		            if { $valid } {		  
                               optionsPassed -pass { blankOut }
                               set returnValue 1
			    }
			 }
	              }   		       
		   }
		}
             }
	  }   		      
       }
    }
    return $returnValue   	  
}

proc test_sddsdiff { args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}    

proc test_tek2sdds {args} {
    set returnValue 1
    global finalResults
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_editstring {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 0
    global finalResults
    set execute "{$testProgramName} {-editcommand=2d2F2(DF)e2Bfd3i/I/2bdi/9/aS/two/Ks/six/f2yakdeyazreya2Zodeya%h/two/22/%/seven/77/%g/two/Two/} {one two three four five six seven eight nine ten}"
    if [catch {eval exec $execute} results] {
	append finalResults "editstring\n$execute\n$results\n"
    } else {
	set valid 0
	if {$results == "77 eight nI9Ine tenefoufour six Two Two"} {
	    set valid 1
	}
	if {$valid} {
	    optionsPassed -pass {editcommand}
	    set returnValue 1
	} else {
	    append finalResults "editstring\n$execute\n$results\n\nCorrect answer is:\n77 eight nI9Ine tenefoufour six Two Two"
	}
    }
    return $returnValue
    APSSetVarAndUpdate status "Testing for this program is not available yet."
    return $returnValue
}

proc test_sdds2dinterpolate {args} {
    APSStrictParseArguments {testProgramName inDir outFile}
    set returnValue 1
    global finalResults
    #testing nn method
    #example1 
    APSSetVarAndUpdate status "nn example1: Franke test function reconstruction by 100, 300 and 1000 random points with nn sibmon method and extrapolation"
    foreach nm {100 300 1000} {
        set valid 0
        set execute "$testProgramName ${inDir}sdds2dinterpolate_nn1-${nm}.sdds $outFile -outDimen=x=256,y=256 -weight=inf"
        if [catch {eval exec $execute} results] {
            append finalResults "$testProgramName\n$execute\n$results\n"
            return 0
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -execute $execute \
                -standardFile ${inDir}sdds2dinterpolate_nn1-${nm}.output -testFile $outFile
            if !$valid {
                return 0
            }
        }
    }
    #example2
    APSSetVarAndUpdate status "nn example2: Linear interpolation...(no extrapolation)"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn2.sdds $outFile -algorithm=nn,linear -outDimension=x=256,y=256"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn2.linear.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    APSSetVarAndUpdate status "nn example2: Natural Neighbours Sibson interpolation. (wmin=0, no extrapolation)"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn2.sdds  $outFile -outDimension=x=256,y=256"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn2.nn0.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    APSSetVarAndUpdate status "nn example2: Natural Neighbours Sibson interpolation with wmin = inf... (with extrapolation)"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn2.sdds  $outFile -outDimension=x=256,y=256 -weight=inf"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn2.nninf.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    APSSetVarAndUpdate status "nn example2: Natural Neighbours Non-Sibsonian interpolation with wmin = 0.(no extrapolation, -weight=0 is default)"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn2.sdds  $outFile -outDimension=x=256,y=256 -weight=0 -algorithm=nn,nonsibson"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn2.ns0.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    APSSetVarAndUpdate status "nn example3 interpolation of degenerate data"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn3.sdds $outFile -file=${inDir}sdds2dinterpolate_nn3-points.sdds -weight=inf"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn3.nn.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn3.sdds $outFile -file=${inDir}sdds2dinterpolate_nn3-points.sdds -algorithm=nn,nonsibson -weight=inf"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn3.ns.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    APSSetVarAndUpdate status "nn example4:  run on a topographic data from satellite altimeter"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn4.sdds $outFile -outDimens=x=201,y=201 -algorithm=nn,linear"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn4.linear.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn4.sdds $outFile -outDimens=x=201,y=201 -weight=0"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn4.nn0.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn4.sdds $outFile -outDimens=x=201,y=201 -weight=inf"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn4.nninf.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn4.sdds $outFile -outDimens=x=201,y=201 -weight=0 -algorithm=nn,nonsibson"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn4.ns0.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    APSSetVarAndUpdate status "nn example5: run on elevation data obtained from digitised contours"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn5.sdds $outFile  -outDimens=x=373,y=455  -algorithm=nn,linear"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn5.linear.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn5.sdds $outFile  -outDimens=x=373,y=455"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn5.nn0.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    APSSetVarAndUpdate status "nn Example 6: based on digitised elevation contours"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_nn6.sdds $outFile -outDimen=x=152,y=114 -weight=0  -range=xmin=591020.57127923,xmax=591321.93673645,ymax=4260093.61151167,ymin=4259867.85217794"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_nn6.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    APSSetVarAndUpdate status "csa example1: reconstruction the Franke test function"
    foreach nm {5 10 15} {
        set execute "$testProgramName ${inDir}sdds2dinterpolate_csa1-${nm}.sdds $outFile -algorithm=csa -out=x=256,y=256"
        if [catch {eval exec $execute} results] {
            append finalResults "$testProgramName\n$execute\n$results\n"
            return 0
        } else {
            set valid 0
            compareOutput -testProgramName $testProgramName -execute $execute \
                -standardFile ${inDir}sdds2dinterpolate_csa1-${nm}.output -testFile $outFile
            if !$valid {
                return 0
            }
        }
    }
    
    APSSetVarAndUpdate status "csa example2: approximation of some real-life bathymetry data from echosounder"
    set execute "$testProgramName ${inDir}sdds2dinterpolate_csa2.sdds $outFile -algorithm=csa -out=x=256,y=256"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_csa2.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_csa2.sdds $outFile -algorithm=csa,average=20 -out=x=256,y=256"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_csa2.nppc20.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_csa2.sdds $outFile -algorithm=csa,sensitivity=280 -out=x=256,y=256"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_csa2.k280.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate_csa2.sdds $outFile -algorithm=csa,sensitivity=70 -out=x=256,y=256"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate_csa2.k70.output -testFile $outFile
        if !$valid {
            return 0
        }
    }
    APSSetVarAndUpdate status "csa example3: approximation of data with known error"
    foreach type {P F} {
        foreach nm {100 300 100} {
            set execute "$testProgramName ${inDir}sdds2dinterpolate_csa3-${type}${nm}.sdds $outFile -out=x=256,y=256 \
                       -algorithm=csa,average=15,sensitivity=70"
            
            if [catch {eval exec $execute} results] {
                append finalResults "$testProgramName\n$execute\n$results\n"
                return 0
            } else {
                set valid 0
                compareOutput -testProgramName $testProgramName -execute $execute \
                    -standardFile ${inDir}sdds2dinterpolate_csa3-${type}${nm}.output -testFile $outFile
                if !$valid {
                    return 0
                }
            }
        }
    }
    optionsPassed -pass {algorithm range outDimension weight file}
    APSSetVarAndUpdate status "testing other options..."
    #test other options
    set execute "$testProgramName ${inDir}sdds2dinterpolate.input $outFile -scale=circle -zoom=1.2 -dimensionThin=x=2,y=2 -npoints=20 -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission"
     
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate.output1 -testFile $outFile
        if !$valid {
            return 0
        }
    }
    
    set execute "$testProgramName ${inDir}sdds2dinterpolate.input $outFile -scale=square -clusterThin=1.2 -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate.output2 -testFile $outFile
        if !$valid {
            return 0
        }
    }
    optionsPassed -pass {scale zoom clusterThin dimensionThin independentColumn dependentColumn}
    set execute "$testProgramName ${inDir}sdds2dinterpolate.input $outFile -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission -npoints=10"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate.output3 -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "$testProgramName ${inDir}sdds2dinterpolate.input $outFile -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate.output4 -testFile $outFile
        if !$valid {
            return 0
        }
    }
    optionsPassed -pass {npoints}
    set execute "$testProgramName ${inDir}sdds2dinterpolate.input -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission -pipe=out \
           | sddsconvert -pipe=in $outFile"
    set execute "$testProgramName ${inDir}sdds2dinterpolate.input $outFile -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate.output4 -testFile $outFile
        if !$valid {
            return 0
        }
    }
    set execute "sddsconvert ${inDir}sdds2dinterpolate.input -pipe=out -retain=col,nux,nuy,Transmission \
              | $testProgramName  -pipe=in $outFile -outdim=x=20,y=20 -indep=xcol=nux,ycol=nuy -dep=Transmission"
    if [catch {eval exec $execute} results] {
        append finalResults "$testProgramName\n$execute\n$results\n"
        return 0
    } else {
        set valid 0
        compareOutput -testProgramName $testProgramName -execute $execute \
            -standardFile ${inDir}sdds2dinterpolate.output4 -testFile $outFile
        if !$valid {
            return 0
        }
    }
    optionsPassed -pass {pipe}
    return 1
}
