[Shunit-commits] ShUnit/test autoSuiteUnitTest, NONE, 1.1 bashUnitAcceptanceTest, NONE, 1.1 shUnitAcceptanceTest, NONE, 1.1 shUnitPlusAcceptanceTest, NONE, 1.1 shUnitPlusTest, NONE, 1.1 shUnitTest, NONE, 1.1 shUnitTestSuite, NONE, 1.1

[lacton <la...@us...>]

Update of /cvsroot/shunit/ShUnit/test
In directory fdv4jf1.ch3.sourceforge.com:/tmp/cvs-serv15292/test

Added Files:
	autoSuiteUnitTest bashUnitAcceptanceTest shUnitAcceptanceTest 
	shUnitPlusAcceptanceTest shUnitPlusTest shUnitTest 
	shUnitTestSuite 
Log Message:
Moved framework test files to 'test/' subdirectory


--- NEW FILE: shUnitPlusTest ---
#! /usr/bin/env sh

################################################################################
# shUnitPlusTest
# 2004-01-28 Steve Cline
# $Id: shUnitPlusTest,v 1.1 2008/11/02 17:22:58 lacton Exp $
################################################################################

#
# find the shUnit file using the command as a reference
#
inherit() {
    d=`expr "${0}" : '\([a-zA-Z/._-]*\/\)'`
    test `expr "$d" : '[./]'` -eq 0 && d="./$d"
    . ../${d}${1}
}

inherit shUnitPlus

tmpDir=`basename ${0}`.$$
inputDir=${tmpDir}/tmp/currentInput
outputDir=${tmpDir}/tmp/currentOutput
testData=${tmpDir}/tmp/tOnly/data
testFile=${testData}/test.txt
logsDir=${tmpDir}/logs

shuSetUp() {
  test ! -d $inputDir  && mkdir -p $inputDir
  test ! -d $outputDir && mkdir -p $outputDir
  test ! -d $testData  && mkdir -p $testData
  test ! -d $logsDir  && mkdir -p $logsDir

  echo "OK">$testFile
  cp $testFile $inputDir
}

shuTearDown() {
  test -d "$tmpDir" && rm -rf "$tmpDir"
}

TestEnvironmentVars() {
  shuStringEqual "My String" "My String"
  [ -n "$testData" ]
  shuAssert "testData set:" $?
}

TestDirectoriesExist() {
  shuEnsureDirectoryExists $inputDir
  shuEnsureDirectoryExists $outputDir
  shuEnsureDirectoryExists $testData
}

TestSetup() {
  shuNonZeroFile $inputDir/test.txt
  shuNoFile $/non/existant/file
}

TestIntegerEqual() {
  shuIntegerEqual 1 1
}

TestOutputFiles() {
  cp $inputDir/test.txt $outputDir
  shuFileLineCount $outputDir/test.txt 1
  shuMatchFiles $outputDir/test.txt $testData/test.txt
}

TestFileAge() {
  cp $inputDir/test.txt $testData
  shuFileOlderThan /bin/ls $testData/test.txt 
}


TestAll() {
  shuRegTest TestEnvironmentVars
  shuRegTest TestDirectoriesExist
  shuRegTest TestSetup
  shuRegTest TestIntegerEqual
  shuRegTest TestOutputFiles
  shuRegTest TestFileAge
} 


### Main

shuStart TestAll


--- NEW FILE: shUnitTestSuite ---
#! /usr/bin/env sh

./shUnitTest &&
./shUnitPlusTest &&
./autoSuiteUnitTest &&
./shUnitAcceptanceTest &&
./bashUnitAcceptanceTest &&
(cd .. && ./moneyTest -t) &&
echo "Test suite run successful" || echo "Test suite run FAILED!"


--- NEW FILE: shUnitAcceptanceTest ---
#! /usr/bin/env sh

#
# Acceptance tests for ShUnit that should work with all Bourne derived shells.
# Any failing test here should be considered a portability defect.
#

#
# Test Cases
#

Suite() {
  shuRegTest TestNoTest
  shuRegTest Test1SuccessfulTest
  shuRegTest Test1FailingTest
  shuRegTest Test2SuccessfulTests
  shuRegTest Test1SuccessAnd1FailureInTheSameTest
  shuRegTest Test1SuccessAnd1FailureInDifferentTests
  shuRegTest Test126FailingTests
  shuRegTest Test127FailingTests
  shuRegTest TestShuStartWith2Arguments
}

TestNoTest() {
  for shell in $available_shells
  do
    SuiteWithNoTest() {
      runEmbeddedTest $shell "Suite() { :; }"
    }
    stdout=`SuiteWithNoTest 2>/dev/null`
    stderr=`SuiteWithNoTest 2>&1 >/dev/null`
    [ 127 -eq $? ]
    shuAssert "Expected exit code 127 with $shell" $?
    assertContains 'shUnit: No tests to run' "$stderr" "$shell"
  done
}

Test1SuccessfulTest() {
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "
      SuccessfulTest() { shuAssert 'Always true' 0; }
      Suite() { shuRegTest SuccessfulTest; }"`
    [ 0 -eq $? ]
    shuAssert "Expected exit code 0 with $shell" $?
    assertContains '1 test succeeded.' "$stdout" "$shell"
    assertContains 'No tests failed.' "$stdout" "$shell"
  done
}

Test1FailingTest() {
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "
      FailingTest() { shuAssert 'Always false' 1; }
      Suite() { shuRegTest FailingTest; }"`
    [ 1 -eq $? ]
    shuAssert "Expected exit code 1 with $shell" $?
    assertContains 'No tests succeeded.' "$stdout" "$shell"
    assertContains '1 test failed.' "$stdout" "$shell"
  done
}

Test2SuccessfulTests() {
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "
      FirstSuccessfulTest() { shuAssert 'Always true' 0;  }
      SecondSuccessfulTest() { shuAssert 'Always true' 0; }
      Suite() { shuRegTest FirstSuccessfulTest; shuRegTest SecondSuccessfulTest; }"`
    [ 0 -eq $? ]
    shuAssert "Expected exit code 0 with $shell" $?
    assertContains '2 tests succeeded.' "$stdout" "$shell"
    assertContains 'No tests failed.' "$stdout" "$shell"
  done
}

Test1SuccessAnd1FailureInTheSameTest() {
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "
      TestWithASuccessAndAFailure() {
        shuAssert 'Always false' 1
        shuAssert 'Always true' 0
      }
      Suite() { shuRegTest TestWithASuccessAndAFailure; }"`
    [ 1 -eq $? ]
    shuAssert "Expected exit code 1 with $shell" $?
    assertContains 'No tests succeeded.' "$stdout" "$shell"
    assertContains '1 test failed.' "$stdout" "$shell"
  done
}

Test1SuccessAnd1FailureInDifferentTests() {
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "
      SuccessfulTest() {  shuAssert 'Always true' 0; }
      FailingTest() { shuAssert 'Always false' 1; }
      Suite() { shuRegTest SuccessfulTest; shuRegTest FailingTest; }"`
    [ 1 -eq $? ]
    shuAssert "Expected exit code 1 with $shell" $?
    assertContains '1 test succeeded.' "$stdout" "$shell"
    assertContains '1 test failed.' "$stdout" "$shell"
  done
}

Test126FailingTests() {
  scriptWith126Failures=`scriptWithNFailures 126`
  
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "$scriptWith126Failures"`
    [ 126 -eq $? ]
    shuAssert "Expected exit code 126 with $shell" $?
  done
}

Test127FailingTests() {
  scriptWith127Failures=`scriptWithNFailures 127`
  
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "$scriptWith127Failures"`
    [ 126 -eq $? ]
    shuAssert "Expected exit code 126 with $shell" $?
  done
}

TestShuStartWith2Arguments() {
  for shell in $available_shells
  do
    shuStartWith2Arguments() {
      $shell <<-EOF
        Test1() { shuAssert 'Always true' 0; }
        Suite1() { shuRegTest Test1; }
        Suite2() { shuRegTest Test1; }
        . "../shUnit"
        shuStart Suite1 Suite2
EOF
    }
    stdout=`shuStartWith2Arguments 2>/dev/null`
    stderr=`shuStartWith2Arguments 2>&1 >/dev/null`
    
    shuDeny "Exit code should be KO" $?
    
    test "" = "$stdout"
    shuAssert "Standard output should be empty for $shell" $?
    
    test "shuStart: invalid number of arguments -- 2" = "$stderr"
    shuAssert "Error message for $shell" $?
  done
}

#
# Support Functions
#

assertContains() {
  expected_substring="$1"
  actual_string="$2"
  shell="$3"
  
  echo "$actual_string" | grep -q "$expected_substring"
  shuAssert "Expected '$expected_substring' with $shell" $?
}

getAvailableShellsAmong() {
  known_shells="$1"
  for shell in $known_shells
  do
    if (exec $shell -c exit 2>/dev/null)
    then
      echo -n "$shell "
    fi
  done
}

runEmbeddedTest() {
  shell="$1"
  embedded_script="$2"
  
  $shell <<-EOF
    $embedded_script
    . "../shUnit"
    shuStart Suite
EOF
}

scriptWithNFailures() {
  failingTestCount=${1}

  failingTestIdx=1
  testDeclarations=""
  testRegistration=""
  while [ $failingTestIdx -le $failingTestCount ]
  do
    testName="FailingTest$failingTestIdx"
    testDeclarations="$testDeclarations $testName() { shuAssert 'Always false' 1; };"
    testRegistration="$testRegistration shuRegTest $testName;"
    failingTestIdx=`expr $failingTestIdx + 1`
  done
  echo "$testDeclarations Suite() { $testRegistration }"
}

#
# Main
#

available_shells=`getAvailableShellsAmong "sh bash ksh93 pdksh ash dash"`
echo "Available shells: $available_shells" >&2

. "../shUnit"
shuStart Suite

--- NEW FILE: shUnitTest ---
#! /usr/bin/env sh

################################################################################
# $Id: shUnitTest,v 1.1 2008/11/02 17:22:58 lacton Exp $
################################################################################

#
# Unit tests for ShUnit that should work with all Bourne derived shells.
#

#
# find the shUnit file using the command as a reference
#
inherit() {
    d=`expr ${0} : '\([a-zA-Z/._-]*\/\)'`
    [ `expr "$d" : '[./]'` -eq 0 ] && d="./$d"
    . ../${d}${1}
}

inherit shUnit

dummyTest() {
    :
}

TestShuRegTest() {
    orig="${SHU_STR_ALL_TESTS}"

    return=`expr "${SHU_STR_ALL_TESTS}" : ".* dummyTest"`
    shuDeny "dummyTest already exists" $?

    shuRegTest "dummyTest"
    return=`expr "${SHU_STR_ALL_TESTS}" : ".* dummyTest"`
    shuAssert "dummyTest didn't register" $?

    SHU_STR_ALL_TESTS=${orig}
}

TestShuRunOneTest() {
    orig_total_nr_run="${shuTestNbr}"
    orig_total_nr_succeeded="${SHU_TOTAL_NR_SUCCEEDED}"

    before="${shuTestNbr}"
    shuRunOneTest "nonExistantFunction" > /dev/null 2>&1
    after="${shuTestNbr}"
    test_succeeded_flag_after="${SHU_TEST_SUCCEEDED}"
    SHU_TEST_SUCCEEDED=${SHU_TRUE}

    [ $before -eq $after ]
    shuAssert "shuTestNbr increased after running non-existant test" $?

    [ $test_succeeded_flag_after -eq ${SHU_FALSE} ]
    shuAssert "SHU_TEST_SUCCEEDED not set to false after running non-existant test" $?

    shuTestNbr=${orig_total_nr_run}
    SHU_TOTAL_NR_SUCCEEDED=${orig_total_nr_succeeded}
}

shuSetUp() {
    touch ./test.$$
}

shuTearDown() {
    [ -f ./test.$$ ] && rm ./test.$$
}

TestSetupCalledCorrectly() {
    [ -f ./test.$$ ]
    shuAssert "test file not created: " $?
}

TestShuRegisterFailedTest() {
    orig="$SHU_STR_FAILED"

    unset SHU_STR_FAILED
    shuRegisterFailedTest "message1"
    SHU_TEST_SUCCEEDED=${SHU_TRUE}
    [ "$SHU_STR_FAILED" = "message1" ]
    shuAssert "expected 'message1' but got $SHU_STR_FAILED" $?

    shuRegisterFailedTest "message2"
    SHU_TEST_SUCCEEDED=${SHU_TRUE}
    [ "$SHU_STR_FAILED" = "message1^message2" ]
    shuAssert "expected 'message1' but got $SHU_STR_FAILED" $?

    shuRegisterFailedTest "message3"
    SHU_TEST_SUCCEEDED=${SHU_TRUE}
    [ "$SHU_STR_FAILED" = "message1^message2^message3" ]
    shuAssert "expected 'message1^message2' but got $SHU_STR_FAILED" $?

    SHU_STR_FAILED="$orig"
}

TestIntentionalFailure() {
    shuAssert "This test failed intentionally" ${SHU_FALSE}
    [ ${SHU_TEST_SUCCEEDED} -eq ${SHU_FALSE} ]
    shuAssert "Failed test didn't set SHU_TEST_SUCCEEDED to false" $?

    shuAssert "This is another test that failed intentionally" ${SHU_FALSE}
    [ ${SHU_TEST_SUCCEEDED} -eq ${SHU_FALSE} ]
    shuAssert "Failed test didn't set SHU_TEST_SUCCEEDED to false" $?

    SHU_TEST_SUCCEEDED=${SHU_TRUE}
}

TestShuAssert() {
    shuAssert "" "${SHU_TRUE}"
    shuAssert "Test case ${SHU_TRUE} failed" "${SHU_TRUE}"
}

TestShuDeny() {
    shuDeny "" "${SHU_FALSE}"
    shuDeny "return code ${SHU_FALSE} failed" "${SHU_FALSE}"
    shuDeny "return code -1 failed" -1
    shuDeny "return code 222 failed" 222
}

TestShuFmtNbrTests() {
    shuFmtNbrTests 0
    [ "No tests" = "${shuRetFmtNbrTests}" ]
    shuAssert "Failed test case 0 returned [$shuRetFmtNbrTests]" $?

    shuFmtNbrTests 1
    [ "1 test" = "${shuRetFmtNbrTests}" ]
    shuAssert "Failed test case 1 returned [$shuRetFmtNbrTests]" $?

    shuFmtNbrTests 2
    [ "2 tests" = "${shuRetFmtNbrTests}" ]
    shuAssert "Failed test case 2 returned [$shuRetFmtNbrTests]" $?

    shuFmtNbrTests 100
    [ "100 tests" = "${shuRetFmtNbrTests}" ]
    shuAssert "Failed test case 100 returned [$shuRetFmtNbrTests]" $?
}

TestOneAssertFailureAndOneAssertSuccessMeanFailure() {
    shuAssert "This test failed intentionally" ${SHU_FALSE}
    shuAssert "This test succeeded intentionally" ${SHU_TRUE}

    if [ ${SHU_TEST_SUCCEEDED} -eq ${SHU_FALSE} ]
    then
      SHU_TEST_SUCCEEDED=${SHU_TRUE}
    else
      SHU_TEST_SUCCEEDED=${SHU_FALSE}
    fi
    shuAssert "1 assertion failure + 1 assertion success => test failure" ${SHU_TEST_SUCCEEDED}
}

TestOneDenyFailureAndOneDenySuccessMeanFailure() {
    shuDeny "This test failed intentionally" ${SHU_TRUE}
    shuDeny "This test succeeded intentionally" ${SHU_FALSE}

    if [ ${SHU_TEST_SUCCEEDED} -eq ${SHU_FALSE} ]
    then
      SHU_TEST_SUCCEEDED=${SHU_TRUE}
    else
      SHU_TEST_SUCCEEDED=${SHU_FALSE}
    fi
    shuAssert "1 deny failure + 1 deny success => test failure" ${SHU_TEST_SUCCEEDED}
}

Suite() {
  shuRegTest TestIntentionalFailure
  shuRegTest TestShuRegisterFailedTest
  shuRegTest TestShuAssert
  shuRegTest TestShuDeny
  shuRegTest TestShuRegTest
  shuRegTest TestShuRunOneTest
  shuRegTest TestSetupCalledCorrectly
  shuRegTest TestShuFmtNbrTests
  shuRegTest TestOneAssertFailureAndOneAssertSuccessMeanFailure
  shuRegTest TestOneDenyFailureAndOneDenySuccessMeanFailure
} 


### Main

shuStart Suite

--- NEW FILE: shUnitPlusAcceptanceTest ---
#! /usr/bin/env sh

#
# Acceptance tests for ShUnitPlus that should work with all Bourne derived shells.
# Any failing test here should be considered a portability defect.
#

#
# Test Cases
#

Suite() {
  shuRegTest TestCanRunATestAfterLoadingShUnitPlusOnly
}

TestCanRunATestAfterLoadingShUnitPlusOnly() {
  for shell in $available_shells
  do
    stdout=`runEmbeddedTest $shell "
      export SHUNIT_HOME=..
      FailingTest() { shuAssert 'Always wrong' 1; }
      Suite() { shuRegTest FailingTest; }
      . ../shUnitPlus
      shuStart Suite"`
    echo "$stdout" | grep -q '1 test failed.'
    shuAssert "FailingTest should return '1 test failed.'" $?
  done
}

#
# Support Functions
#

getAvailableShellsAmong() {
  known_shells="$1"
  for shell in $known_shells
  do
    if (exec $shell -c exit 2>/dev/null)
    then
      echo -n "$shell "
    fi
  done
}

runEmbeddedTest() {
  shell="$1"
  embedded_script="$2"
  
  $shell <<-EOF
    $embedded_script
EOF
}

#
# Main
#

available_shells=`getAvailableShellsAmong "sh bash ksh93 pdksh ash dash"`
echo "Available shells: $available_shells" >&2

. "../shUnit"
. "../shUnitPlus"
shuStart Suite

--- NEW FILE: bashUnitAcceptanceTest ---
#! /usr/bin/env bash

#
# Acceptance tests for ShUnit that should work with bash, but may not work with other Bourne derived shells.
# A failing test here should be considered a defect only if it fails with bash.
#

#
# Test Cases
#

Suite() {
  shuRegTest TestAutoSuite
}

TestAutoSuite() {
  stdout=`../fixtures/autoSuiteTest`
  shuAssert "Expected successful exit code" $?
  echo "$stdout" | grep -q 'Test1'
  shuAssert "Expected 'Test1'" $?
  echo "$stdout" | grep -q 'NotATest'
  shuDeny "Expected 'NotATest' to be ignored" $?
}

#
# Support Functions
#

#
# Main
#

. "../shUnit"
shuStart Suite

--- NEW FILE: autoSuiteUnitTest ---
#! /usr/bin/env sh

#
# Test the test suite auto-detection feature.
#

#
# find the shUnit file using the command as a reference
#
inherit() {
    d=`expr ${0} : '\([a-zA-Z/._-]*\/\)'`
    test `expr "$d" : '[./]'` -eq 0 && d="./$d"
    . ../${d}${1}
}

inherit shUnit

#
# Test cases
#

TestGetDeclaredFunctionsWithBash_v3_2() {

  declare() {
    case "$1" in
      -F)
        echo "declare -f func1"
        echo "declare -f func2"
        ;;
      +f)
        echo "...something hard to parse..."
        ;;
      *)
        echo "'$1' option not implemented in this mock function" >&2
        ;;
    esac
  }
  
  typeset() {
    declare "$@"
  }
  
  tests="`shuGetDeclaredFunctions`"
  
  test "$tests" = "`echo "func1"; echo "func2"`"
  shuAssert "shuGetDeclaredFunctions returns the two functions seen by 'declare -F'" $?
}

TestGetDeclaredFunctionsWithKsh93() {

  declare() {
    echo "declare: not found" >&2
    return 127
  }
  
  typeset() {
    if [ "$1" = "+f" ]
    then
      echo "func3() #line 1 /path/to/script"
      echo "func4() #line 2 /path/to/script"
    fi
  }
  
  tests="`shuGetDeclaredFunctions`"
  
  test "$tests" = "`echo "func3"; echo "func4"`"
  shuAssert "shuGetDeclaredFunctions returns the two functions seen by 'typeset +f'" $?
}

TestGetDeclaredFunctionsWithPdksh_v5_2() {

  declare() {
    echo "declare: not found" >&2
    return 127
  }
  
  typeset() {
    if [ "$1" = "+f" ]
    then
      echo "func5"
      echo "func6"
    fi
  }
  
  tests="`shuGetDeclaredFunctions`"
  
  test "$tests" = "`echo "func5"; echo "func6"`"
  shuAssert "shuGetDeclaredFunctions returns the two functions seen by 'typeset +f'" $?
}

TestGetDeclaredFunctionsWhenNeitherDeclareNorTypesetWorks() {

  declare() {
    echo "declare: not found" >&2
    return 127
  }
  
  typeset() {
    echo "typeset: unknown option" >&2
    return 1
  }
  
  functions="`shuGetDeclaredFunctions 2>/dev/null`"
  stderr="`shuGetDeclaredFunctions 2>&1 >/dev/null`"
  
  test -z "$functions"
  shuAssert "shuGetDeclaredFunctions returns no functions" $?
  test "ShUnit did not detect any function. Use the shuRegTest function to register all test functions." = "$stderr"
  shuAssert "shuGetDeclaredFunctions returns a warning message" $?
}

Suite() {
  shuRegTest TestGetDeclaredFunctionsWithBash_v3_2
  shuRegTest TestGetDeclaredFunctionsWithKsh93
  shuRegTest TestGetDeclaredFunctionsWithPdksh_v5_2
  shuRegTest TestGetDeclaredFunctionsWhenNeitherDeclareNorTypesetWorks
}

### Main

shuStart Suite