scripts/shunit/shunit2_test_macros.sh

   1 #! /bin/sh
   2 # $Id: shunit2_test_macros.sh 299 2010-05-03 12:44:20Z kate.ward@forestent.com $
   3 # vim:et:ft=sh:sts=2:sw=2
   4 #
   5 # Copyright 2008 Kate Ward. All Rights Reserved.
   6 # Released under the LGPL (GNU Lesser General Public License)
   7 # Author: kate.ward@forestent.com (Kate Ward)
   8 #
   9 # shUnit2 unit test for macros.
  10
  11 # load test helpers
  12 . ./shunit2_test_helpers
  13
  14 #------------------------------------------------------------------------------
  15 # suite tests
  16 #
  17
  18 testAssertEquals()
  19 {
  20   # start skipping if LINENO not available
  21   [ -z "${LINENO:-}" ] && startSkipping
  22
  23   ( ${_ASSERT_EQUALS_} 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
  24   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  25   rtrn=$?
  26   assertTrue '_ASSERT_EQUALS_ failure' ${rtrn}
  27   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  28
  29   ( ${_ASSERT_EQUALS_} '"some msg"' 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
  30   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  31   rtrn=$?
  32   assertTrue '_ASSERT_EQUALS_ w/ msg failure' ${rtrn}
  33   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  34 }
  35
  36 testAssertNotEquals()
  37 {
  38   # start skipping if LINENO not available
  39   [ -z "${LINENO:-}" ] && startSkipping
  40
  41   ( ${_ASSERT_NOT_EQUALS_} 'x' 'x' >"${stdoutF}" 2>"${stderrF}" )
  42   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  43   rtrn=$?
  44   assertTrue '_ASSERT_NOT_EQUALS_ failure' ${rtrn}
  45   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  46
  47   ( ${_ASSERT_NOT_EQUALS_} '"some msg"' 'x' 'x' >"${stdoutF}" 2>"${stderrF}" )
  48   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  49   rtrn=$?
  50   assertTrue '_ASSERT_NOT_EQUALS_ w/ msg failure' ${rtrn}
  51   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  52 }
  53
  54 testSame()
  55 {
  56   # start skipping if LINENO not available
  57   [ -z "${LINENO:-}" ] && startSkipping
  58
  59   ( ${_ASSERT_SAME_} 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
  60   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  61   rtrn=$?
  62   assertTrue '_ASSERT_SAME_ failure' ${rtrn}
  63   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  64
  65   ( ${_ASSERT_SAME_} '"some msg"' 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
  66   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  67   rtrn=$?
  68   assertTrue '_ASSERT_SAME_ w/ msg failure' ${rtrn}
  69   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  70 }
  71
  72 testNotSame()
  73 {
  74   # start skipping if LINENO not available
  75   [ -z "${LINENO:-}" ] && startSkipping
  76
  77   ( ${_ASSERT_NOT_SAME_} 'x' 'x' >"${stdoutF}" 2>"${stderrF}" )
  78   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  79   rtrn=$?
  80   assertTrue '_ASSERT_NOT_SAME_ failure' ${rtrn}
  81   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  82
  83   ( ${_ASSERT_NOT_SAME_} '"some msg"' 'x' 'x' >"${stdoutF}" 2>"${stderrF}" )
  84   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  85   rtrn=$?
  86   assertTrue '_ASSERT_NOT_SAME_ w/ msg failure' ${rtrn}
  87   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
  88 }
  89
  90 testNull()
  91 {
  92   # start skipping if LINENO not available
  93   [ -z "${LINENO:-}" ] && startSkipping
  94
  95   ( ${_ASSERT_NULL_} 'x' >"${stdoutF}" 2>"${stderrF}" )
  96   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
  97   rtrn=$?
  98   assertTrue '_ASSERT_NULL_ failure' ${rtrn}
  99   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 100
 101   ( ${_ASSERT_NULL_} '"some msg"' 'x' >"${stdoutF}" 2>"${stderrF}" )
 102   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 103   rtrn=$?
 104   assertTrue '_ASSERT_NULL_ w/ msg failure' ${rtrn}
 105   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 106 }
 107
 108 testNotNull()
 109 {
 110   # start skipping if LINENO not available
 111   [ -z "${LINENO:-}" ] && startSkipping
 112
 113   ( ${_ASSERT_NOT_NULL_} '' >"${stdoutF}" 2>"${stderrF}" )
 114   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 115   rtrn=$?
 116   assertTrue '_ASSERT_NOT_NULL_ failure' ${rtrn}
 117   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 118
 119   ( ${_ASSERT_NOT_NULL_} '"some msg"' '""' >"${stdoutF}" 2>"${stderrF}" )
 120   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 121   rtrn=$?
 122   assertTrue '_ASSERT_NOT_NULL_ w/ msg failure' ${rtrn}
 123   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stdoutF}" "${stderrF}" >&2
 124 }
 125
 126 testAssertTrue()
 127 {
 128   # start skipping if LINENO not available
 129   [ -z "${LINENO:-}" ] && startSkipping
 130
 131   ( ${_ASSERT_TRUE_} ${SHUNIT_FALSE} >"${stdoutF}" 2>"${stderrF}" )
 132   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 133   rtrn=$?
 134   assertTrue '_ASSERT_TRUE_ failure' ${rtrn}
 135   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 136
 137
 138   ( ${_ASSERT_TRUE_} '"some msg"' ${SHUNIT_FALSE} >"${stdoutF}" 2>"${stderrF}" )
 139   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 140   rtrn=$?
 141   assertTrue '_ASSERT_TRUE_ w/ msg failure' ${rtrn}
 142   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 143 }
 144
 145 testAssertFalse()
 146 {
 147   # start skipping if LINENO not available
 148   [ -z "${LINENO:-}" ] && startSkipping
 149
 150   ( ${_ASSERT_FALSE_} ${SHUNIT_TRUE} >"${stdoutF}" 2>"${stderrF}" )
 151   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 152   rtrn=$?
 153   assertTrue '_ASSERT_FALSE_ failure' ${rtrn}
 154   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 155
 156   ( ${_ASSERT_FALSE_} '"some msg"' ${SHUNIT_TRUE} >"${stdoutF}" 2>"${stderrF}" )
 157   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 158   rtrn=$?
 159   assertTrue '_ASSERT_FALSE_ w/ msg failure' ${rtrn}
 160   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 161 }
 162
 163 testFail()
 164 {
 165   # start skipping if LINENO not available
 166   [ -z "${LINENO:-}" ] && startSkipping
 167
 168   ( ${_FAIL_} >"${stdoutF}" 2>"${stderrF}" )
 169   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 170   rtrn=$?
 171   assertTrue '_FAIL_ failure' ${rtrn}
 172   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 173
 174   ( ${_FAIL_} '"some msg"' >"${stdoutF}" 2>"${stderrF}" )
 175   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 176   rtrn=$?
 177   assertTrue '_FAIL_ w/ msg failure' ${rtrn}
 178   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 179 }
 180
 181 testFailNotEquals()
 182 {
 183   # start skipping if LINENO not available
 184   [ -z "${LINENO:-}" ] && startSkipping
 185
 186   ( ${_FAIL_NOT_EQUALS_} 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
 187   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 188   rtrn=$?
 189   assertTrue '_FAIL_NOT_EQUALS_ failure' ${rtrn}
 190   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 191
 192   ( ${_FAIL_NOT_EQUALS_} '"some msg"' 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
 193   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 194   rtrn=$?
 195   assertTrue '_FAIL_NOT_EQUALS_ w/ msg failure' ${rtrn}
 196   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 197 }
 198
 199 testFailSame()
 200 {
 201   # start skipping if LINENO not available
 202   [ -z "${LINENO:-}" ] && startSkipping
 203
 204   ( ${_FAIL_SAME_} 'x' 'x' >"${stdoutF}" 2>"${stderrF}" )
 205   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 206   rtrn=$?
 207   assertTrue '_FAIL_SAME_ failure' ${rtrn}
 208   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 209
 210   ( ${_FAIL_SAME_} '"some msg"' 'x' 'x' >"${stdoutF}" 2>"${stderrF}" )
 211   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 212   rtrn=$?
 213   assertTrue '_FAIL_SAME_ w/ msg failure' ${rtrn}
 214   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 215 }
 216
 217 testFailNotSame()
 218 {
 219   # start skipping if LINENO not available
 220   [ -z "${LINENO:-}" ] && startSkipping
 221
 222   ( ${_FAIL_NOT_SAME_} 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
 223   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 224   rtrn=$?
 225   assertTrue '_FAIL_NOT_SAME_ failure' ${rtrn}
 226   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 227
 228   ( ${_FAIL_NOT_SAME_} '"some msg"' 'x' 'y' >"${stdoutF}" 2>"${stderrF}" )
 229   grep '^ASSERT:\[[0-9]*\] *' "${stdoutF}" >/dev/null
 230   rtrn=$?
 231   assertTrue '_FAIL_NOT_SAME_ w/ msg failure' ${rtrn}
 232   [ ${rtrn} -ne ${SHUNIT_TRUE} ] && cat "${stderrF}" >&2
 233 }
 234
 235 #------------------------------------------------------------------------------
 236 # suite functions
 237 #
 238
 239 oneTimeSetUp()
 240 {
 241   tmpDir="${__shunit_tmpDir}/output"
 242   mkdir "${tmpDir}"
 243   stdoutF="${tmpDir}/stdout"
 244   stderrF="${tmpDir}/stderr"
 245 }
 246
 247 # load and run shUnit2
 248 [ -n "${ZSH_VERSION:-}" ] && SHUNIT_PARENT=$0
 249 . ${TH_SHUNIT}