exiv2/test/functions.source

#!/bin/bash

##
# run a test
runTest()
{
    local prog=$1
    shift
    (
        cd $here/tmp
        if [ ! -z $EXIV2_ECHO ]; then
            echoTest $VALGRIND $bin/$prog "$@"
        fi
        $VALGRIND $bin/$prog "$@"
    )
}

##
# echo commands and arguments
echoTest()
{
    local count=1
    for i in $@ ; do
        echo $((count++)):  $i
    done
    echo -----------------------
}

##
# predictate
existsTest()
{
    local prog=$1
    result=0
    if [ -e $bin/$prog -o -e $bin/$prog.exe ]; then
        result=1
    fi
    echo $result
}

##
# copy file
copy()
{
    \cp "$1" "$2"
}

##
# copy file from data to tmp (copyTestFile from to
copyTestFile()
{
    if [ $# == 2 ]; then
        cp -f "$here/data/$1" "$here/tmp/$2"
    elif [ $# == 1 ]; then
        cp -f "$here/data/$1" "$here/tmp/$1"
    else
        echo "*** error copyTestFile: illegal number of inputs = $# ***"
    fi
    
}

##
# copy 1 or more files from data to tmp
copyTestFiles()
{
    for i in "$@" ; do
        copyTestFile "$i" "$i"
    done
}

##
# result analysis
reportTest()
{
    cat $results | tr '\\' '/' > ${results}-new
        mv -f ${results}-new $results
    if [ ! -z `which dos2unix` ]; then
        unix2dos $results >/dev/null 2>&1
    fi

    if [ $# -eq 0 ]; then
        lhs=$results
        rhs=$good
    else 
        if [ $# -eq 3 ] ; then
            diffargs=$1
            lhs=$2
            rhs=$3
        else 
            lhs=$1
            rhs=$2
        fi
    fi

    if [ "$PLATFORM" == "cygwin" ]; then
        diff -q $diffargs $(cygpath -aw $lhs) $(cygpath -aw $rhs)
    else
        diff -q $diffargs $lhs $rhs
    fi
    rc=$?
    if [ $rc -eq 0 ] ; then
        echo "all testcases passed."
    else
        diff $diffargs $lhs $rhs
    fi
}

##
# moved here from write-test.sh
# Function: 
#     runTestCase number file
# Params:
#     number: Test case number
#     file  : Input file
# Abstract:
# Run the requested test case number with the given file
runTestCase()
{
    rtc_number=$1
    rtc_infile=$2

    rtc_outfile=test${rtc_number}.jpg
    rtc_jpgthumb=thumb${rtc_number}.jpg
    rtc_tifthumb=thumb${rtc_number}.tif

    rm -f $rtc_outfile $rtc_jpgthumb $rtc_tifthumb
    rm -f iii ttt; 

    echo "------------------------------------------------------------"
    runTest exifprint $rtc_infile > iii;
    cp $rtc_infile $rtc_outfile; 
    runTest write-test $rtc_infile $rtc_number > ttt; 
    diff -a iii ttt
}

##
# moved here from bugfixes-test.sh
prep_file()
{
    echo `prep_any_file $1 exiv2-bug$1.jpg`
}

prep_empty_file()
{
    echo `prep_any_file $1 exiv2-empty.jpg`
}

prep_any_file()
{
    printf "$1 " >&3
    echo '------>' Bug $1 '<-------' >&2
    copyTestFile $2 exiv2-bug$1.jpg
    echo exiv2-bug$1.jpg
}

##
# moved here from imagetest.sh
eraseTest()
{
    src=$1
    test=${src}.etst
    good=$datapath/${src}.egd

    #setup
    cp $datapath/$src $test

    #run tests
    $bin/metacopy $test $test

    #check results
    diffCheck $test $good
    printf "."
}

copyTest()
{
    num=$1
    src=$2
    dst=$3
    test=${dst}.c${num}tst
    good=$datapath/${dst}.c${num}gd

    #setup
    cp $datapath/$dst $test

    #run tests
    $bin/metacopy -a $datapath/$src $test

    #check results
    diffCheck $test $good
    printf "."
}

iptcTest()
{
    num=$1
    src=$2
    dst=$3
    test=${dst}.i${num}tst
    good=$datapath/${dst}.i${num}gd

    #setup
    cp $datapath/$dst $test

    #run tests
    runTest metacopy -ip $datapath/$src $test

    #check results
    diffCheck $test $good
    printf "."
}

# Make sure to pass the test file first and the known good file second
diffCheck() 
{
    test=$1
    good=$2
    
    #run diff and check results
    diff -q --binary $diffargs $test $good
    if [ $? -ne 0 ]; then
       errors=`expr $errors + 1`
    else
       rm $test
    fi 
}


##
# moved here from iotest.sh
ioTest()
{
    src=$datapath/$1
    out1=${1}.1
    out2=${1}.2

    #run tests
    runTest iotest $src $out1 $out2
    if [ $? -ne 0 ]; then
       errors=`expr $errors + 1`
       return
    fi 

    #check results
    diffCheck $out1 $src 
    diffCheck $out2 $src 
    printf "."
}


##
# moved here from iptctest.sh
printTest()
{
    src=$1
    test=${src}.iptst
    good=$datapath/${src}.ipgd

    #run tests
    runTest iptcprint $datapath/$src > $test

    #check results
    diffCheck $test $good
    printf "."
}

removeTest()
{
    src=$1
    tmp="temp"
    test=${src}.irtst
    good=$datapath/${src}.irgd

    #setup
    cp $datapath/$src $tmp

    #run tests
    runTest iptctest $tmp <<-eoc
        r Iptc.Application2.Byline
        r Iptc.Application2.Caption
        r Iptc.Application2.Keywords
        r Iptc.Application2.Keywords
        r Iptc.Application2.Keywords
        r Iptc.Application2.CountryName
eoc
    runTest iptcprint $tmp > $test

    #check results
    diffCheck $test $good
    printf "."
    rm $tmp
}

addModTest()
{
    src=$1
    tmp="temp"
    test=${src}.iatst
    good=$datapath/${src}.iagd

    #setup
    cp $datapath/$src $tmp

    #run tests
    runTest iptctest $tmp <<-eoc
        a Iptc.Application2.Headline          The headline I am
        a Iptc.Application2.Keywords          Yet another keyword
        m Iptc.Application2.DateCreated       2004-8-3
        a Iptc.Application2.Urgency           3
        m Iptc.Application2.SuppCategory      "bla bla ba"
        a Iptc.Envelope.ModelVersion          2
        a Iptc.Envelope.TimeSent              14:41:0-05:00
        a Iptc.Application2.RasterizedCaption 230 42 34 2 90 84 23 146
eoc
    runTest iptcprint $tmp > $test

    #check results
    diffCheck $test $good
    printf "."
    rm $tmp
}

extendedTest()
{
    src=$1
    tmp="temp"
    test=${src}.ixtst
    good=$datapath/${src}.ixgd

    #setup
    cp $datapath/$src $tmp

    #run tests
    runTest iptctest $tmp < $datapath/ext.dat
    runTest iptcprint $tmp > $test

    #check results
    diffCheck $test $good
    printf "."
    rm $tmp
}

##
# http://stackoverflow.com/questions/1055671/how-can-i-get-the-behavior-of-gnus-readlink-f-on-a-mac
real_path ()
{
    OIFS=$IFS
    IFS='/'
    for I in $1; do
        # Resolve relative path punctuation.
        if [ "$I" = "." ] || [ -z "$I" ]; then
            continue
        elif [ "$I" = ".." ]; then
            FOO="${FOO%%/${FOO##*/}}"
            continue
        else
            FOO="${FOO}/${I}"
        fi

        ## Resolve symbolic links
        if [ -h "$FOO" ];   then
            IFS=$OIFS
            set `ls -l "$FOO"`
            while shift ; do
                if [ "$1" = "->" ];     then
                    FOO=$2
                    shift $#
                    break
                fi
            done
            IFS='/'
        fi
    done
    IFS=$OIFS
    echo "$FOO"
}

##
# prepare temp files and other variables
prepareTest()
{
    ##
    # locale setting
    export LC_ALL=C

    ##
    # initialize globals
    this=$(basename $0 .sh)
    here=$PWD
    datapath="../data"
    testdir="$here/tmp"
    datadir="../data"

    if [ -z "$EXIV2_BINDIR" ] ; then
        bin="$here/../bin"
    else
        bin="$EXIV2_BINDIR"
    fi

    os=$(uname)
    if [ "${os:0:4}" == "CYGW" ]; then
        export PLATFORM=cygwin
    else
        export PLATFORM=$os
    fi

    if [ "$PLATFORM" == cygwin -o "$PLATFORM" == mingw ]; then
        exe=.exe
    fi
    
    if [ "$PLATFORM" == cygwin -o "$PLATFORM" == mingw ]; then
        # We need a private version of diff for linux compatibility
        diff()
        {
            args=()
            for i in "$@"; do
                if [ ${i:0:1} != '-' ]; then
                    i="$(cygpath -aw $i)"
                fi
                args+=($i)
            done
            DIFF=$(readlink -f "$here/../msvc2003/diff$exe")
            chmod +x "$DIFF"
                     "$DIFF" ${args[@]}
        }
    fi

    ##
    # figure out arguments for diff
    diffargs="--strip-trailing-cr"
    good="$here/data/${this}.out"
    results="$here/tmp/${this}.out"

    tmpfile=$here/tmp/$this
    touch $tmpfile
    diff -q $diffargs $tmpfile $tmpfile 2>/dev/null
    if [ $? -ne 0 ]; then
        diffargs=""
    fi
    
    tmpfile=tmp/ttt
    touch $tmpfile
    da1="--strip-trailing-cr"
    diff -q $da1 $tmpfile $tmpfile 2>/dev/null
    if [ $? -ne 0 ] ; then
        da1=""
    fi
    da2="--ignore-matching-lines=^Usage:.*exiv2"
    diff -q $da2 $tmpfile $tmpfile 2>/dev/null
    if [ $? -ne 0 ] ; then
        da2=""
    fi
    diffargs="$da1 $da2"

    ##
    # test that exiv2 and some sample apps are in the bin!
    for e in exiv2 exifprint; do
        e="${bin}/${e}${exe}"
        if [ ! -e "$e" ]; then
            echo '******************************************'
            echo '***' $(real_path "$e") does not exist
            echo '******************************************'
            exit 42
        fi
    done
}

prepareTest

# That's all Folks!
##