jshn: properly support JSON "null" type
[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 $?