switch from typeof to the more portable __typeof__
[project/libubox.git] / examples / shunit2
1 #! /bin/sh
2 # $Id$
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 #
8 # shUnit2 -- Unit testing framework for Unix shell scripts.
9 # http://code.google.com/p/shunit2/
10 #
11 # Author: kate.ward@forestent.com (Kate Ward)
12 #
13 # shUnit2 is a xUnit based unit test framework for Bourne shell scripts. It is
14 # based on the popular JUnit unit testing framework for Java.
15
16 # return if shunit already loaded
17 [ -n "${SHUNIT_VERSION:-}" ] && exit 0
18 SHUNIT_VERSION='2.1.7pre'
19
20 # return values that scripts can use
21 SHUNIT_TRUE=0
22 SHUNIT_FALSE=1
23 SHUNIT_ERROR=2
24
25 # logging functions
26 _shunit_warn() { echo "shunit2:WARN $@" >&2; }
27 _shunit_error() { echo "shunit2:ERROR $@" >&2; }
28 _shunit_fatal() { echo "shunit2:FATAL $@" >&2; exit ${SHUNIT_ERROR}; }
29
30 # determine some reasonable command defaults
31 __SHUNIT_UNAME_S=`uname -s`
32 case "${__SHUNIT_UNAME_S}" in
33   BSD) __SHUNIT_EXPR_CMD='gexpr' ;;
34   *) __SHUNIT_EXPR_CMD='expr' ;;
35 esac
36
37 # commands a user can override if needed
38 SHUNIT_EXPR_CMD=${SHUNIT_EXPR_CMD:-${__SHUNIT_EXPR_CMD}}
39
40 # enable strict mode by default
41 SHUNIT_STRICT=${SHUNIT_STRICT:-${SHUNIT_TRUE}}
42
43 # specific shell checks
44 if [ -n "${ZSH_VERSION:-}" ]; then
45   setopt |grep "^shwordsplit$" >/dev/null
46   if [ $? -ne ${SHUNIT_TRUE} ]; then
47     _shunit_fatal 'zsh shwordsplit option is required for proper operation'
48   fi
49   if [ -z "${SHUNIT_PARENT:-}" ]; then
50     _shunit_fatal "zsh does not pass \$0 through properly. please declare \
51 \"SHUNIT_PARENT=\$0\" before calling shUnit2"
52   fi
53 fi
54
55 #
56 # constants
57 #
58
59 __SHUNIT_ASSERT_MSG_PREFIX='ASSERT:'
60 __SHUNIT_MODE_SOURCED='sourced'
61 __SHUNIT_MODE_STANDALONE='standalone'
62 __SHUNIT_PARENT=${SHUNIT_PARENT:-$0}
63
64 # set the constants readonly
65 __shunit_constants=`set |grep '^__SHUNIT_' |cut -d= -f1`
66 echo "${__shunit_constants}" |grep '^Binary file' >/dev/null && \
67     __shunit_constants=`set |grep -a '^__SHUNIT_' |cut -d= -f1`
68 for __shunit_const in ${__shunit_constants}; do
69   if [ -z "${ZSH_VERSION:-}" ]; then
70     readonly ${__shunit_const}
71   else
72     case ${ZSH_VERSION} in
73       [123].*) readonly ${__shunit_const} ;;
74       *) readonly -g ${__shunit_const}  # declare readonly constants globally
75     esac
76   fi
77 done
78 unset __shunit_const __shunit_constants
79
80 #
81 # internal variables
82 #
83
84 # variables
85 __shunit_lineno=''  # line number of executed test
86 __shunit_mode=${__SHUNIT_MODE_SOURCED}  # operating mode
87 __shunit_reportGenerated=${SHUNIT_FALSE}  # is report generated
88 __shunit_script=''  # filename of unittest script (standalone mode)
89 __shunit_skip=${SHUNIT_FALSE}  # is skipping enabled
90 __shunit_suite=''  # suite of tests to execute
91
92 # counts of tests
93 __shunit_testSuccess=${SHUNIT_TRUE}
94 __shunit_testsTotal=0
95 __shunit_testsPassed=0
96 __shunit_testsFailed=0
97
98 # counts of asserts
99 __shunit_assertsTotal=0
100 __shunit_assertsPassed=0
101 __shunit_assertsFailed=0
102 __shunit_assertsSkipped=0
103
104 # macros
105 _SHUNIT_LINENO_='eval __shunit_lineno=""; if [ "${1:-}" = "--lineno" ]; then [ -n "$2" ] && __shunit_lineno="[$2] "; shift 2; fi'
106
107 #-----------------------------------------------------------------------------
108 # private functions
109
110 #-----------------------------------------------------------------------------
111 # assert functions
112 #
113
114 # Assert that two values are equal to one another.
115 #
116 # Args:
117 #   message: string: failure message [optional]
118 #   expected: string: expected value
119 #   actual: string: actual value
120 # Returns:
121 #   integer: success (TRUE/FALSE/ERROR constant)
122 assertEquals()
123 {
124   ${_SHUNIT_LINENO_}
125   if [ $# -lt 2 -o $# -gt 3 ]; then
126     _shunit_error "assertEquals() requires two or three arguments; $# given"
127     _shunit_error "1: ${1:+$1} 2: ${2:+$2} 3: ${3:+$3}${4:+ 4: $4}"
128     return ${SHUNIT_ERROR}
129   fi
130   _shunit_shouldSkip && return ${SHUNIT_TRUE}
131
132   shunit_message_=${__shunit_lineno}
133   if [ $# -eq 3 ]; then
134     shunit_message_="${shunit_message_}$1"
135     shift
136   fi
137   shunit_expected_=$1
138   shunit_actual_=$2
139
140   shunit_return=${SHUNIT_TRUE}
141   if [ "${shunit_expected_}" = "${shunit_actual_}" ]; then
142     _shunit_assertPass
143   else
144     failNotEquals "${shunit_message_}" "${shunit_expected_}" "${shunit_actual_}"
145     shunit_return=${SHUNIT_FALSE}
146   fi
147
148   unset shunit_message_ shunit_expected_ shunit_actual_
149   return ${shunit_return}
150 }
151 _ASSERT_EQUALS_='eval assertEquals --lineno "${LINENO:-}"'
152
153 # Assert that two values are not equal to one another.
154 #
155 # Args:
156 #   message: string: failure message [optional]
157 #   expected: string: expected value
158 #   actual: string: actual value
159 # Returns:
160 #   integer: success (TRUE/FALSE/ERROR constant)
161 assertNotEquals()
162 {
163   ${_SHUNIT_LINENO_}
164   if [ $# -lt 2 -o $# -gt 3 ]; then
165     _shunit_error "assertNotEquals() requires two or three arguments; $# given"
166     return ${SHUNIT_ERROR}
167   fi
168   _shunit_shouldSkip && return ${SHUNIT_TRUE}
169
170   shunit_message_=${__shunit_lineno}
171   if [ $# -eq 3 ]; then
172     shunit_message_="${shunit_message_}$1"
173     shift
174   fi
175   shunit_expected_=$1
176   shunit_actual_=$2
177
178   shunit_return=${SHUNIT_TRUE}
179   if [ "${shunit_expected_}" != "${shunit_actual_}" ]; then
180     _shunit_assertPass
181   else
182     failSame "${shunit_message_}" "$@"
183     shunit_return=${SHUNIT_FALSE}
184   fi
185
186   unset shunit_message_ shunit_expected_ shunit_actual_
187   return ${shunit_return}
188 }
189 _ASSERT_NOT_EQUALS_='eval assertNotEquals --lineno "${LINENO:-}"'
190
191 # Assert that a value is null (i.e. an empty string)
192 #
193 # Args:
194 #   message: string: failure message [optional]
195 #   actual: string: actual value
196 # Returns:
197 #   integer: success (TRUE/FALSE/ERROR constant)
198 assertNull()
199 {
200   ${_SHUNIT_LINENO_}
201   if [ $# -lt 1 -o $# -gt 2 ]; then
202     _shunit_error "assertNull() requires one or two arguments; $# given"
203     return ${SHUNIT_ERROR}
204   fi
205   _shunit_shouldSkip && return ${SHUNIT_TRUE}
206
207   shunit_message_=${__shunit_lineno}
208   if [ $# -eq 2 ]; then
209     shunit_message_="${shunit_message_}$1"
210     shift
211   fi
212   assertTrue "${shunit_message_}" "[ -z '$1' ]"
213   shunit_return=$?
214
215   unset shunit_message_
216   return ${shunit_return}
217 }
218 _ASSERT_NULL_='eval assertNull --lineno "${LINENO:-}"'
219
220 # Assert that a value is not null (i.e. a non-empty string)
221 #
222 # Args:
223 #   message: string: failure message [optional]
224 #   actual: string: actual value
225 # Returns:
226 #   integer: success (TRUE/FALSE/ERROR constant)
227 assertNotNull()
228 {
229   ${_SHUNIT_LINENO_}
230   if [ $# -gt 2 ]; then  # allowing 0 arguments as $1 might actually be null
231     _shunit_error "assertNotNull() requires one or two arguments; $# given"
232     return ${SHUNIT_ERROR}
233   fi
234   _shunit_shouldSkip && return ${SHUNIT_TRUE}
235
236   shunit_message_=${__shunit_lineno}
237   if [ $# -eq 2 ]; then
238     shunit_message_="${shunit_message_}$1"
239     shift
240   fi
241   shunit_actual_=`_shunit_escapeCharactersInString "${1:-}"`
242   test -n "${shunit_actual_}"
243   assertTrue "${shunit_message_}" $?
244   shunit_return=$?
245
246   unset shunit_actual_ shunit_message_
247   return ${shunit_return}
248 }
249 _ASSERT_NOT_NULL_='eval assertNotNull --lineno "${LINENO:-}"'
250
251 # Assert that two values are the same (i.e. equal to one another).
252 #
253 # Args:
254 #   message: string: failure message [optional]
255 #   expected: string: expected value
256 #   actual: string: actual value
257 # Returns:
258 #   integer: success (TRUE/FALSE/ERROR constant)
259 assertSame()
260 {
261   ${_SHUNIT_LINENO_}
262   if [ $# -lt 2 -o $# -gt 3 ]; then
263     _shunit_error "assertSame() requires two or three arguments; $# given"
264     return ${SHUNIT_ERROR}
265   fi
266   _shunit_shouldSkip && return ${SHUNIT_TRUE}
267
268   shunit_message_=${__shunit_lineno}
269   if [ $# -eq 3 ]; then
270     shunit_message_="${shunit_message_}$1"
271     shift
272   fi
273   assertEquals "${shunit_message_}" "$1" "$2"
274   shunit_return=$?
275
276   unset shunit_message_
277   return ${shunit_return}
278 }
279 _ASSERT_SAME_='eval assertSame --lineno "${LINENO:-}"'
280
281 # Assert that two values are not the same (i.e. not equal to one another).
282 #
283 # Args:
284 #   message: string: failure message [optional]
285 #   expected: string: expected value
286 #   actual: string: actual value
287 # Returns:
288 #   integer: success (TRUE/FALSE/ERROR constant)
289 assertNotSame()
290 {
291   ${_SHUNIT_LINENO_}
292   if [ $# -lt 2 -o $# -gt 3 ]; then
293     _shunit_error "assertNotSame() requires two or three arguments; $# given"
294     return ${SHUNIT_ERROR}
295   fi
296   _shunit_shouldSkip && return ${SHUNIT_TRUE}
297
298   shunit_message_=${__shunit_lineno}
299   if [ $# -eq 3 ]; then
300     shunit_message_="${shunit_message_:-}$1"
301     shift
302   fi
303   assertNotEquals "${shunit_message_}" "$1" "$2"
304   shunit_return=$?
305
306   unset shunit_message_
307   return ${shunit_return}
308 }
309 _ASSERT_NOT_SAME_='eval assertNotSame --lineno "${LINENO:-}"'
310
311 # Assert that a value or shell test condition is true.
312 #
313 # In shell, a value of 0 is true and a non-zero value is false. Any integer
314 # value passed can thereby be tested.
315 #
316 # Shell supports much more complicated tests though, and a means to support
317 # them was needed. As such, this function tests that conditions are true or
318 # false through evaluation rather than just looking for a true or false.
319 #
320 # The following test will succeed:
321 #   assertTrue 0
322 #   assertTrue "[ 34 -gt 23 ]"
323 # The folloing test will fail with a message:
324 #   assertTrue 123
325 #   assertTrue "test failed" "[ -r '/non/existant/file' ]"
326 #
327 # Args:
328 #   message: string: failure message [optional]
329 #   condition: string: integer value or shell conditional statement
330 # Returns:
331 #   integer: success (TRUE/FALSE/ERROR constant)
332 assertTrue()
333 {
334   ${_SHUNIT_LINENO_}
335   if [ $# -lt 1 -o $# -gt 2 ]; then
336     _shunit_error "assertTrue() takes one or two arguments; $# given"
337     return ${SHUNIT_ERROR}
338   fi
339   _shunit_shouldSkip && return ${SHUNIT_TRUE}
340
341   shunit_message_=${__shunit_lineno}
342   if [ $# -eq 2 ]; then
343     shunit_message_="${shunit_message_}$1"
344     shift
345   fi
346   shunit_condition_=$1
347
348   # see if condition is an integer, i.e. a return value
349   shunit_match_=`expr "${shunit_condition_}" : '\([0-9]*\)'`
350   shunit_return=${SHUNIT_TRUE}
351   if [ -z "${shunit_condition_}" ]; then
352     # null condition
353     shunit_return=${SHUNIT_FALSE}
354   elif [ -n "${shunit_match_}" -a "${shunit_condition_}" = "${shunit_match_}" ]
355   then
356     # possible return value. treating 0 as true, and non-zero as false.
357     [ ${shunit_condition_} -ne 0 ] && shunit_return=${SHUNIT_FALSE}
358   else
359     # (hopefully) a condition
360     ( eval ${shunit_condition_} ) >/dev/null 2>&1
361     [ $? -ne 0 ] && shunit_return=${SHUNIT_FALSE}
362   fi
363
364   # record the test
365   if [ ${shunit_return} -eq ${SHUNIT_TRUE} ]; then
366     _shunit_assertPass
367   else
368     _shunit_assertFail "${shunit_message_}"
369   fi
370
371   unset shunit_message_ shunit_condition_ shunit_match_
372   return ${shunit_return}
373 }
374 _ASSERT_TRUE_='eval assertTrue --lineno "${LINENO:-}"'
375
376 # Assert that a value or shell test condition is false.
377 #
378 # In shell, a value of 0 is true and a non-zero value is false. Any integer
379 # value passed can thereby be tested.
380 #
381 # Shell supports much more complicated tests though, and a means to support
382 # them was needed. As such, this function tests that conditions are true or
383 # false through evaluation rather than just looking for a true or false.
384 #
385 # The following test will succeed:
386 #   assertFalse 1
387 #   assertFalse "[ 'apples' = 'oranges' ]"
388 # The folloing test will fail with a message:
389 #   assertFalse 0
390 #   assertFalse "test failed" "[ 1 -eq 1 -a 2 -eq 2 ]"
391 #
392 # Args:
393 #   message: string: failure message [optional]
394 #   condition: string: integer value or shell conditional statement
395 # Returns:
396 #   integer: success (TRUE/FALSE/ERROR constant)
397 assertFalse()
398 {
399   ${_SHUNIT_LINENO_}
400   if [ $# -lt 1 -o $# -gt 2 ]; then
401     _shunit_error "assertFalse() quires one or two arguments; $# given"
402     return ${SHUNIT_ERROR}
403   fi
404   _shunit_shouldSkip && return ${SHUNIT_TRUE}
405
406   shunit_message_=${__shunit_lineno}
407   if [ $# -eq 2 ]; then
408     shunit_message_="${shunit_message_}$1"
409     shift
410   fi
411   shunit_condition_=$1
412
413   # see if condition is an integer, i.e. a return value
414   shunit_match_=`expr "${shunit_condition_}" : '\([0-9]*\)'`
415   shunit_return=${SHUNIT_TRUE}
416   if [ -z "${shunit_condition_}" ]; then
417     # null condition
418     shunit_return=${SHUNIT_FALSE}
419   elif [ -n "${shunit_match_}" -a "${shunit_condition_}" = "${shunit_match_}" ]
420   then
421     # possible return value. treating 0 as true, and non-zero as false.
422     [ ${shunit_condition_} -eq 0 ] && shunit_return=${SHUNIT_FALSE}
423   else
424     # (hopefully) a condition
425     ( eval ${shunit_condition_} ) >/dev/null 2>&1
426     [ $? -eq 0 ] && shunit_return=${SHUNIT_FALSE}
427   fi
428
429   # record the test
430   if [ ${shunit_return} -eq ${SHUNIT_TRUE} ]; then
431     _shunit_assertPass
432   else
433     _shunit_assertFail "${shunit_message_}"
434   fi
435
436   unset shunit_message_ shunit_condition_ shunit_match_
437   return ${shunit_return}
438 }
439 _ASSERT_FALSE_='eval assertFalse --lineno "${LINENO:-}"'
440
441 #-----------------------------------------------------------------------------
442 # failure functions
443 #
444
445 # Records a test failure.
446 #
447 # Args:
448 #   message: string: failure message [optional]
449 # Returns:
450 #   integer: success (TRUE/FALSE/ERROR constant)
451 fail()
452 {
453   ${_SHUNIT_LINENO_}
454   if [ $# -gt 1 ]; then
455     _shunit_error "fail() requires zero or one arguments; $# given"
456     return ${SHUNIT_ERROR}
457   fi
458   _shunit_shouldSkip && return ${SHUNIT_TRUE}
459
460   shunit_message_=${__shunit_lineno}
461   if [ $# -eq 1 ]; then
462     shunit_message_="${shunit_message_}$1"
463     shift
464   fi
465
466   _shunit_assertFail "${shunit_message_}"
467
468   unset shunit_message_
469   return ${SHUNIT_FALSE}
470 }
471 _FAIL_='eval fail --lineno "${LINENO:-}"'
472
473 # Records a test failure, stating two values were not equal.
474 #
475 # Args:
476 #   message: string: failure message [optional]
477 #   expected: string: expected value
478 #   actual: string: actual value
479 # Returns:
480 #   integer: success (TRUE/FALSE/ERROR constant)
481 failNotEquals()
482 {
483   ${_SHUNIT_LINENO_}
484   if [ $# -lt 2 -o $# -gt 3 ]; then
485     _shunit_error "failNotEquals() requires one or two arguments; $# given"
486     return ${SHUNIT_ERROR}
487   fi
488   _shunit_shouldSkip && return ${SHUNIT_TRUE}
489
490   shunit_message_=${__shunit_lineno}
491   if [ $# -eq 3 ]; then
492     shunit_message_="${shunit_message_}$1"
493     shift
494   fi
495   shunit_expected_=$1
496   shunit_actual_=$2
497
498   _shunit_assertFail "${shunit_message_:+${shunit_message_} }expected:<${shunit_expected_}> but was:<${shunit_actual_}>"
499
500   unset shunit_message_ shunit_expected_ shunit_actual_
501   return ${SHUNIT_FALSE}
502 }
503 _FAIL_NOT_EQUALS_='eval failNotEquals --lineno "${LINENO:-}"'
504
505 # Records a test failure, stating two values should have been the same.
506 #
507 # Args:
508 #   message: string: failure message [optional]
509 #   expected: string: expected value
510 #   actual: string: actual value
511 # Returns:
512 #   integer: success (TRUE/FALSE/ERROR constant)
513 failSame()
514 {
515   ${_SHUNIT_LINENO_}
516   if [ $# -lt 2 -o $# -gt 3 ]; then
517     _shunit_error "failSame() requires two or three arguments; $# given"
518     return ${SHUNIT_ERROR}
519   fi
520   _shunit_shouldSkip && return ${SHUNIT_TRUE}
521
522   shunit_message_=${__shunit_lineno}
523   if [ $# -eq 3 ]; then
524     shunit_message_="${shunit_message_}$1"
525     shift
526   fi
527
528   _shunit_assertFail "${shunit_message_:+${shunit_message_} }expected not same"
529
530   unset shunit_message_
531   return ${SHUNIT_FALSE}
532 }
533 _FAIL_SAME_='eval failSame --lineno "${LINENO:-}"'
534
535 # Records a test failure, stating two values were not equal.
536 #
537 # This is functionally equivalent to calling failNotEquals().
538 #
539 # Args:
540 #   message: string: failure message [optional]
541 #   expected: string: expected value
542 #   actual: string: actual value
543 # Returns:
544 #   integer: success (TRUE/FALSE/ERROR constant)
545 failNotSame()
546 {
547   ${_SHUNIT_LINENO_}
548   if [ $# -lt 2 -o $# -gt 3 ]; then
549     _shunit_error "failNotEquals() requires one or two arguments; $# given"
550     return ${SHUNIT_ERROR}
551   fi
552   _shunit_shouldSkip && return ${SHUNIT_TRUE}
553
554   shunit_message_=${__shunit_lineno}
555   if [ $# -eq 3 ]; then
556     shunit_message_="${shunit_message_}$1"
557     shift
558   fi
559   failNotEquals "${shunit_message_}" "$1" "$2"
560   shunit_return=$?
561
562   unset shunit_message_
563   return ${shunit_return}
564 }
565 _FAIL_NOT_SAME_='eval failNotSame --lineno "${LINENO:-}"'
566
567 #-----------------------------------------------------------------------------
568 # skipping functions
569 #
570
571 # Force remaining assert and fail functions to be "skipped".
572 #
573 # This function forces the remaining assert and fail functions to be "skipped",
574 # i.e. they will have no effect. Each function skipped will be recorded so that
575 # the total of asserts and fails will not be altered.
576 #
577 # Args:
578 #   None
579 startSkipping()
580 {
581   __shunit_skip=${SHUNIT_TRUE}
582 }
583
584 # Resume the normal recording behavior of assert and fail calls.
585 #
586 # Args:
587 #   None
588 endSkipping()
589 {
590   __shunit_skip=${SHUNIT_FALSE}
591 }
592
593 # Returns the state of assert and fail call skipping.
594 #
595 # Args:
596 #   None
597 # Returns:
598 #   boolean: (TRUE/FALSE constant)
599 isSkipping()
600 {
601   return ${__shunit_skip}
602 }
603
604 #-----------------------------------------------------------------------------
605 # suite functions
606 #
607
608 # Stub. This function should contains all unit test calls to be made.
609 #
610 # DEPRECATED (as of 2.1.0)
611 #
612 # This function can be optionally overridden by the user in their test suite.
613 #
614 # If this function exists, it will be called when shunit2 is sourced. If it
615 # does not exist, shunit2 will search the parent script for all functions
616 # beginning with the word 'test', and they will be added dynamically to the
617 # test suite.
618 #
619 # This function should be overridden by the user in their unit test suite.
620 # Note: see _shunit_mktempFunc() for actual implementation
621 #
622 # Args:
623 #   None
624 #suite() { :; }  # DO NOT UNCOMMENT THIS FUNCTION
625
626 # Adds a function name to the list of tests schedule for execution.
627 #
628 # This function should only be called from within the suite() function.
629 #
630 # Args:
631 #   function: string: name of a function to add to current unit test suite
632 suite_addTest()
633 {
634   shunit_func_=${1:-}
635
636   __shunit_suite="${__shunit_suite:+${__shunit_suite} }${shunit_func_}"
637   __shunit_testsTotal=`expr ${__shunit_testsTotal} + 1`
638
639   unset shunit_func_
640 }
641
642 # Stub. This function will be called once before any tests are run.
643 #
644 # Common one-time environment preparation tasks shared by all tests can be
645 # defined here.
646 #
647 # This function should be overridden by the user in their unit test suite.
648 # Note: see _shunit_mktempFunc() for actual implementation
649 #
650 # Args:
651 #   None
652 #oneTimeSetUp() { :; }  # DO NOT UNCOMMENT THIS FUNCTION
653
654 # Stub. This function will be called once after all tests are finished.
655 #
656 # Common one-time environment cleanup tasks shared by all tests can be defined
657 # here.
658 #
659 # This function should be overridden by the user in their unit test suite.
660 # Note: see _shunit_mktempFunc() for actual implementation
661 #
662 # Args:
663 #   None
664 #oneTimeTearDown() { :; }  # DO NOT UNCOMMENT THIS FUNCTION
665
666 # Stub. This function will be called before each test is run.
667 #
668 # Common environment preparation tasks shared by all tests can be defined here.
669 #
670 # This function should be overridden by the user in their unit test suite.
671 # Note: see _shunit_mktempFunc() for actual implementation
672 #
673 # Args:
674 #   None
675 #setUp() { :; }
676
677 # Note: see _shunit_mktempFunc() for actual implementation
678 # Stub. This function will be called after each test is run.
679 #
680 # Common environment cleanup tasks shared by all tests can be defined here.
681 #
682 # This function should be overridden by the user in their unit test suite.
683 # Note: see _shunit_mktempFunc() for actual implementation
684 #
685 # Args:
686 #   None
687 #tearDown() { :; }  # DO NOT UNCOMMENT THIS FUNCTION
688
689 #------------------------------------------------------------------------------
690 # internal shUnit2 functions
691 #
692
693 # Create a temporary directory to store various run-time files in.
694 #
695 # This function is a cross-platform temporary directory creation tool. Not all
696 # OSes have the mktemp function, so one is included here.
697 #
698 # Args:
699 #   None
700 # Outputs:
701 #   string: the temporary directory that was created
702 _shunit_mktempDir()
703 {
704   # try the standard mktemp function
705   ( exec mktemp -dqt shunit.XXXXXX 2>/dev/null ) && return
706
707   # the standard mktemp didn't work.  doing our own.
708   if [ -r '/dev/urandom' -a -x '/usr/bin/od' ]; then
709     _shunit_random_=`/usr/bin/od -vAn -N4 -tx4 </dev/urandom \
710         |sed 's/^[^0-9a-f]*//'`
711   elif [ -n "${RANDOM:-}" ]; then
712     # $RANDOM works
713     _shunit_random_=${RANDOM}${RANDOM}${RANDOM}$$
714   else
715     # $RANDOM doesn't work
716     _shunit_date_=`date '+%Y%m%d%H%M%S'`
717     _shunit_random_=`expr ${_shunit_date_} / $$`
718   fi
719
720   _shunit_tmpDir_="${TMPDIR:-/tmp}/shunit.${_shunit_random_}"
721   ( umask 077 && mkdir "${_shunit_tmpDir_}" ) || \
722       _shunit_fatal 'could not create temporary directory! exiting'
723
724   echo ${_shunit_tmpDir_}
725   unset _shunit_date_ _shunit_random_ _shunit_tmpDir_
726 }
727
728 # This function is here to work around issues in Cygwin.
729 #
730 # Args:
731 #   None
732 _shunit_mktempFunc()
733 {
734   for _shunit_func_ in oneTimeSetUp oneTimeTearDown setUp tearDown suite noexec
735   do
736     _shunit_file_="${__shunit_tmpDir}/${_shunit_func_}"
737     cat <<EOF >"${_shunit_file_}"
738 #! /bin/sh
739 exit ${SHUNIT_TRUE}
740 EOF
741     chmod +x "${_shunit_file_}"
742   done
743
744   unset _shunit_file_
745 }
746
747 # Final cleanup function to leave things as we found them.
748 #
749 # Besides removing the temporary directory, this function is in charge of the
750 # final exit code of the unit test. The exit code is based on how the script
751 # was ended (e.g. normal exit, or via Ctrl-C).
752 #
753 # Args:
754 #   name: string: name of the trap called (specified when trap defined)
755 _shunit_cleanup()
756 {
757   _shunit_name_=$1
758
759   case ${_shunit_name_} in
760     EXIT) _shunit_signal_=0 ;;
761     INT) _shunit_signal_=2 ;;
762     TERM) _shunit_signal_=15 ;;
763     *)
764       _shunit_warn "unrecognized trap value (${_shunit_name_})"
765       _shunit_signal_=0
766       ;;
767   esac
768
769   # do our work
770   rm -fr "${__shunit_tmpDir}"
771
772   # exit for all non-EXIT signals
773   if [ ${_shunit_name_} != 'EXIT' ]; then
774     _shunit_warn "trapped and now handling the (${_shunit_name_}) signal"
775     # disable EXIT trap
776     trap 0
777     # add 128 to signal and exit
778     exit `expr ${_shunit_signal_} + 128`
779   elif [ ${__shunit_reportGenerated} -eq ${SHUNIT_FALSE} ] ; then
780     _shunit_assertFail 'Unknown failure encountered running a test'
781     _shunit_generateReport
782     exit ${SHUNIT_ERROR}
783   fi
784
785   unset _shunit_name_ _shunit_signal_
786 }
787
788 # The actual running of the tests happens here.
789 #
790 # Args:
791 #   None
792 _shunit_execSuite()
793 {
794   for _shunit_test_ in ${__shunit_suite}; do
795     __shunit_testSuccess=${SHUNIT_TRUE}
796
797     # disable skipping
798     endSkipping
799
800     # execute the per-test setup function
801     setUp
802
803     # execute the test
804     echo "${_shunit_test_}"
805     eval ${_shunit_test_}
806
807     # execute the per-test tear-down function
808     tearDown
809
810     # update stats
811     if [ ${__shunit_testSuccess} -eq ${SHUNIT_TRUE} ]; then
812       __shunit_testsPassed=`expr ${__shunit_testsPassed} + 1`
813     else
814       __shunit_testsFailed=`expr ${__shunit_testsFailed} + 1`
815     fi
816   done
817
818   unset _shunit_test_
819 }
820
821 # Generates the user friendly report with appropriate OK/FAILED message.
822 #
823 # Args:
824 #   None
825 # Output:
826 #   string: the report of successful and failed tests, as well as totals.
827 _shunit_generateReport()
828 {
829   _shunit_ok_=${SHUNIT_TRUE}
830
831   # if no exit code was provided one, determine an appropriate one
832   [ ${__shunit_testsFailed} -gt 0 \
833       -o ${__shunit_testSuccess} -eq ${SHUNIT_FALSE} ] \
834           && _shunit_ok_=${SHUNIT_FALSE}
835
836   echo
837   if [ ${__shunit_testsTotal} -eq 1 ]; then
838     echo "Ran ${__shunit_testsTotal} test."
839   else
840     echo "Ran ${__shunit_testsTotal} tests."
841   fi
842
843   _shunit_failures_=''
844   _shunit_skipped_=''
845   [ ${__shunit_assertsFailed} -gt 0 ] \
846       && _shunit_failures_="failures=${__shunit_assertsFailed}"
847   [ ${__shunit_assertsSkipped} -gt 0 ] \
848       && _shunit_skipped_="skipped=${__shunit_assertsSkipped}"
849
850   if [ ${_shunit_ok_} -eq ${SHUNIT_TRUE} ]; then
851     _shunit_msg_='OK'
852     [ -n "${_shunit_skipped_}" ] \
853         && _shunit_msg_="${_shunit_msg_} (${_shunit_skipped_})"
854   else
855     _shunit_msg_="FAILED (${_shunit_failures_}"
856     [ -n "${_shunit_skipped_}" ] \
857         && _shunit_msg_="${_shunit_msg_},${_shunit_skipped_}"
858     _shunit_msg_="${_shunit_msg_})"
859   fi
860
861   echo
862   echo ${_shunit_msg_}
863   __shunit_reportGenerated=${SHUNIT_TRUE}
864
865   unset _shunit_failures_ _shunit_msg_ _shunit_ok_ _shunit_skipped_
866 }
867
868 # Test for whether a function should be skipped.
869 #
870 # Args:
871 #   None
872 # Returns:
873 #   boolean: whether the test should be skipped (TRUE/FALSE constant)
874 _shunit_shouldSkip()
875 {
876   [ ${__shunit_skip} -eq ${SHUNIT_FALSE} ] && return ${SHUNIT_FALSE}
877   _shunit_assertSkip
878 }
879
880 # Records a successful test.
881 #
882 # Args:
883 #   None
884 _shunit_assertPass()
885 {
886   __shunit_assertsPassed=`expr ${__shunit_assertsPassed} + 1`
887   __shunit_assertsTotal=`expr ${__shunit_assertsTotal} + 1`
888 }
889
890 # Records a test failure.
891 #
892 # Args:
893 #   message: string: failure message to provide user
894 _shunit_assertFail()
895 {
896   _shunit_msg_=$1
897
898   __shunit_testSuccess=${SHUNIT_FALSE}
899   __shunit_assertsFailed=`expr ${__shunit_assertsFailed} + 1`
900   __shunit_assertsTotal=`expr ${__shunit_assertsTotal} + 1`
901   echo "${__SHUNIT_ASSERT_MSG_PREFIX}${_shunit_msg_}"
902
903   unset _shunit_msg_
904 }
905
906 # Records a skipped test.
907 #
908 # Args:
909 #   None
910 _shunit_assertSkip()
911 {
912   __shunit_assertsSkipped=`expr ${__shunit_assertsSkipped} + 1`
913   __shunit_assertsTotal=`expr ${__shunit_assertsTotal} + 1`
914 }
915
916 # Prepare a script filename for sourcing.
917 #
918 # Args:
919 #   script: string: path to a script to source
920 # Returns:
921 #   string: filename prefixed with ./ (if necessary)
922 _shunit_prepForSourcing()
923 {
924   _shunit_script_=$1
925   case "${_shunit_script_}" in
926     /*|./*) echo "${_shunit_script_}" ;;
927     *) echo "./${_shunit_script_}" ;;
928   esac
929   unset _shunit_script_
930 }
931
932 # Escape a character in a string.
933 #
934 # Args:
935 #   c: string: unescaped character
936 #   s: string: to escape character in
937 # Returns:
938 #   string: with escaped character(s)
939 _shunit_escapeCharInStr()
940 {
941   [ -n "$2" ] || return  # no point in doing work on an empty string
942
943   # Note: using shorter variable names to prevent conflicts with
944   # _shunit_escapeCharactersInString().
945   _shunit_c_=$1
946   _shunit_s_=$2
947
948
949   # escape the character
950   echo ''${_shunit_s_}'' |sed 's/\'${_shunit_c_}'/\\\'${_shunit_c_}'/g'
951
952   unset _shunit_c_ _shunit_s_
953 }
954
955 # Escape a character in a string.
956 #
957 # Args:
958 #   str: string: to escape characters in
959 # Returns:
960 #   string: with escaped character(s)
961 _shunit_escapeCharactersInString()
962 {
963   [ -n "$1" ] || return  # no point in doing work on an empty string
964
965   _shunit_str_=$1
966
967   # Note: using longer variable names to prevent conflicts with
968   # _shunit_escapeCharInStr().
969   for _shunit_char_ in '"' '$' "'" '`'; do
970     _shunit_str_=`_shunit_escapeCharInStr "${_shunit_char_}" "${_shunit_str_}"`
971   done
972
973   echo "${_shunit_str_}"
974   unset _shunit_char_ _shunit_str_
975 }
976
977 # Extract list of functions to run tests against.
978 #
979 # Args:
980 #   script: string: name of script to extract functions from
981 # Returns:
982 #   string: of function names
983 _shunit_extractTestFunctions()
984 {
985   _shunit_script_=$1
986
987   # extract the lines with test function names, strip of anything besides the
988   # function name, and output everything on a single line.
989   _shunit_regex_='^[    ]*(function )*test[A-Za-z0-9_]* *\(\)'
990   egrep "${_shunit_regex_}" "${_shunit_script_}" \
991   |sed 's/^[^A-Za-z0-9_]*//;s/^function //;s/\([A-Za-z0-9_]*\).*/\1/g' \
992   |xargs
993
994   unset _shunit_regex_ _shunit_script_
995 }
996
997 #------------------------------------------------------------------------------
998 # main
999 #
1000
1001 # determine the operating mode
1002 if [ $# -eq 0 ]; then
1003   __shunit_script=${__SHUNIT_PARENT}
1004   __shunit_mode=${__SHUNIT_MODE_SOURCED}
1005 else
1006   __shunit_script=$1
1007   [ -r "${__shunit_script}" ] || \
1008       _shunit_fatal "unable to read from ${__shunit_script}"
1009   __shunit_mode=${__SHUNIT_MODE_STANDALONE}
1010 fi
1011
1012 # create a temporary storage location
1013 __shunit_tmpDir=`_shunit_mktempDir`
1014
1015 # provide a public temporary directory for unit test scripts
1016 # TODO(kward): document this
1017 SHUNIT_TMPDIR="${__shunit_tmpDir}/tmp"
1018 mkdir "${SHUNIT_TMPDIR}"
1019
1020 # setup traps to clean up after ourselves
1021 trap '_shunit_cleanup EXIT' 0
1022 trap '_shunit_cleanup INT' 2
1023 trap '_shunit_cleanup TERM' 15
1024
1025 # create phantom functions to work around issues with Cygwin
1026 _shunit_mktempFunc
1027 PATH="${__shunit_tmpDir}:${PATH}"
1028
1029 # make sure phantom functions are executable. this will bite if /tmp (or the
1030 # current $TMPDIR) points to a path on a partition that was mounted with the
1031 # 'noexec' option. the noexec command was created with _shunit_mktempFunc().
1032 noexec 2>/dev/null || _shunit_fatal \
1033     'please declare TMPDIR with path on partition with exec permission'
1034
1035 # we must manually source the tests in standalone mode
1036 if [ "${__shunit_mode}" = "${__SHUNIT_MODE_STANDALONE}" ]; then
1037   . "`_shunit_prepForSourcing \"${__shunit_script}\"`"
1038 fi
1039
1040 # execute the oneTimeSetUp function (if it exists)
1041 oneTimeSetUp
1042
1043 # execute the suite function defined in the parent test script
1044 # deprecated as of 2.1.0
1045 suite
1046
1047 # if no suite function was defined, dynamically build a list of functions
1048 if [ -z "${__shunit_suite}" ]; then
1049   shunit_funcs_=`_shunit_extractTestFunctions "${__shunit_script}"`
1050   for shunit_func_ in ${shunit_funcs_}; do
1051     suite_addTest ${shunit_func_}
1052   done
1053 fi
1054 unset shunit_func_ shunit_funcs_
1055
1056 # execute the tests
1057 _shunit_execSuite
1058
1059 # execute the oneTimeTearDown function (if it exists)
1060 oneTimeTearDown
1061
1062 # generate the report
1063 _shunit_generateReport
1064
1065 # that's it folks
1066 [ ${__shunit_testsFailed} -eq 0 ]
1067 exit $?