kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 1 | #! /bin/sh |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 2 | # $Id$ |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 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 | # Author: kate.ward@forestent.com (Kate Ward) |
| 9 | # |
| 10 | # shFlags unit test for the flag definition methods |
| 11 | # |
| 12 | # TODO(kward): assert on FLAGS errors |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 13 | # TODO(kward): testNonStandardIFS() |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 14 | |
kate.ward | c66a5fc | 2013-01-12 23:10:15 +0000 | [diff] [blame] | 15 | # exit immediately if a pipeline or subshell exits with a non-zero status. |
| 16 | #set -e |
| 17 | |
| 18 | # treat unset variables as an error |
| 19 | set -u |
| 20 | |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 21 | # load test helpers |
| 22 | . ./shflags_test_helpers |
| 23 | |
| 24 | #------------------------------------------------------------------------------ |
| 25 | # suite tests |
| 26 | # |
| 27 | |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 28 | testGetoptStandard() |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 29 | { |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 30 | _flags_getoptStandard '-b' >"${stdoutF}" 2>"${stderrF}" |
kate.ward | 619806d | 2008-11-15 19:59:57 +0000 | [diff] [blame] | 31 | rslt=$? |
| 32 | assertTrue "didn't parse valid flag 'b'" ${rslt} |
| 33 | th_showOutput ${rslt} "${stdoutF}" "${stderrF}" |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 34 | |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 35 | _flags_getoptStandard '-x' >"${stdoutF}" 2>"${stderrF}" |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 36 | assertFalse "parsed invalid flag 'x'" $? |
| 37 | } |
| 38 | |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 39 | testGetoptEnhanced() |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 40 | { |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 41 | flags_getoptIsEnh || return |
kate.ward | 271aece | 2008-11-13 01:12:35 +0000 | [diff] [blame] | 42 | |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 43 | _flags_getoptEnhanced '-b' >"${stdoutF}" 2>"${stderrF}" |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 44 | assertTrue "didn't parse valid flag 'b'" $? |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 45 | _flags_getoptEnhanced '--bool' >"${stdoutF}" 2>"${stderrF}" |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 46 | assertTrue "didn't parse valid flag 'bool'" $? |
| 47 | |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 48 | _flags_getoptEnhanced '-x' >"${stdoutF}" 2>"${stderrF}" |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 49 | assertFalse "parsed invalid flag 'x'" $? |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 50 | _flags_getoptEnhanced '--xyz' >"${stdoutF}" 2>"${stderrF}" |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 51 | assertFalse "parsed invalid flag 'xyz'" $? |
| 52 | } |
| 53 | |
kate.ward | e10dd53 | 2013-01-04 21:52:23 +0000 | [diff] [blame] | 54 | testValidBoolsShort() |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 55 | { |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 56 | FLAGS -b >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 57 | r3turn=$? |
| 58 | assertTrue "-b) FLAGS returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 59 | value=${FLAGS_bool:-} |
kate.ward | 0a4f16f | 2013-01-07 22:10:49 +0000 | [diff] [blame] | 60 | assertTrue "-b) boolean was not true (${value})." "${value}" |
| 61 | assertFalse '-b) expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 62 | test ${r3turn} -eq ${FLAGS_TRUE} -a ! -s "${stderrF}" |
kate.ward | abae05d | 2008-11-12 22:37:05 +0000 | [diff] [blame] | 63 | th_showOutput $? "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 64 | |
kate.ward | 0a4f16f | 2013-01-07 22:10:49 +0000 | [diff] [blame] | 65 | DEFINE_boolean bool2 true '2nd boolean' B |
| 66 | FLAGS >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 67 | r3turn=$? |
| 68 | assertTrue "-B) FLAGS returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | 0a4f16f | 2013-01-07 22:10:49 +0000 | [diff] [blame] | 69 | value=${FLAGS_bool2:-} |
| 70 | assertTrue "-B) boolean was not true (${value})" ${value} |
| 71 | assertFalse '-B) expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 72 | test ${r3turn} -eq ${FLAGS_TRUE} -a ! -s "${stderrF}" |
kate.ward | 0a4f16f | 2013-01-07 22:10:49 +0000 | [diff] [blame] | 73 | th_showOutput $? "${stdoutF}" "${stderrF}" |
| 74 | |
| 75 | FLAGS -B >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 76 | r3turn=$? |
| 77 | assertTrue "-B) FLAGS returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | 0a4f16f | 2013-01-07 22:10:49 +0000 | [diff] [blame] | 78 | value=${FLAGS_bool2:-} |
| 79 | assertFalse "-B) boolean was not false (${value})" ${value} |
| 80 | assertFalse '-B) expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 81 | test ${r3turn} -eq ${FLAGS_TRUE} -a ! -s "${stderrF}" |
kate.ward | abae05d | 2008-11-12 22:37:05 +0000 | [diff] [blame] | 82 | th_showOutput $? "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 83 | } |
| 84 | |
kate.ward | e10dd53 | 2013-01-04 21:52:23 +0000 | [diff] [blame] | 85 | # TODO(kate): separate into multiple functions to reflect correct usage |
| 86 | testValidBoolsLong() |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 87 | { |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 88 | flags_getoptIsEnh || return |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 89 | |
kate.ward | e10dd53 | 2013-01-04 21:52:23 +0000 | [diff] [blame] | 90 | # Note: the default value of bool is 'false'. |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 91 | |
| 92 | # leave flag false |
| 93 | FLAGS --nobool >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 94 | r3turn=$? |
| 95 | assertTrue "FLAGS returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 96 | assertFalse '--noXX flag resulted in true value.' ${FLAGS_bool:-} |
kate.ward | e556cbf | 2008-11-13 00:41:59 +0000 | [diff] [blame] | 97 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 98 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 99 | |
| 100 | # flip flag true |
| 101 | FLAGS --bool >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 102 | r3turn=$? |
| 103 | assertTrue "FLAGS returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 104 | assertTrue '--XX flag resulted in false value.' ${FLAGS_bool:-} |
kate.ward | e556cbf | 2008-11-13 00:41:59 +0000 | [diff] [blame] | 105 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 106 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 107 | |
| 108 | # flip flag back false |
| 109 | FLAGS --nobool >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 110 | r3turn=$? |
| 111 | assertTrue "FLAGS returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 112 | assertFalse '--noXX flag resulted in true value.' ${FLAGS_bool:-} |
kate.ward | e556cbf | 2008-11-13 00:41:59 +0000 | [diff] [blame] | 113 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 114 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | testValidFloats() |
| 118 | { |
| 119 | _testValidFloats '-f' |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 120 | flags_getoptIsEnh || return |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 121 | _testValidFloats '--float' |
| 122 | } |
| 123 | |
| 124 | _testValidFloats() |
| 125 | { |
| 126 | flag=$1 |
| 127 | for value in ${TH_FLOAT_VALID}; do |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 128 | FLAGS ${flag} ${value} >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 129 | r3turn=$? |
| 130 | assertTrue "FLAGS ${flag} ${value} returned non-zero result (${r3turn})" \ |
| 131 | ${r3turn} |
kate.ward | 8fe62e6 | 2010-03-28 23:07:35 +0000 | [diff] [blame] | 132 | assertEquals "float (${flag} ${value}) test failed." ${value} ${FLAGS_float} |
kate.ward | e556cbf | 2008-11-13 00:41:59 +0000 | [diff] [blame] | 133 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 134 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 135 | done |
| 136 | } |
| 137 | |
| 138 | testInvalidFloats() |
| 139 | { |
| 140 | _testInvalidFloats '-f' |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 141 | flags_getoptIsEnh || return |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 142 | _testInvalidFloats '--float' |
| 143 | } |
| 144 | |
| 145 | _testInvalidFloats() |
| 146 | { |
| 147 | flag=$1 |
| 148 | for value in ${TH_FLOAT_INVALID}; do |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 149 | th_clearReturn |
| 150 | ( |
| 151 | FLAGS ${flag} ${value} >"${stdoutF}" 2>"${stderrF}" |
| 152 | echo $? >"${returnF}" |
| 153 | ) |
| 154 | th_queryReturn |
| 155 | assertFalse "FLAGS (${value}) returned a zero result" ${th_return} |
kate.ward | e10dd53 | 2013-01-04 21:52:23 +0000 | [diff] [blame] | 156 | assertFalse 'expected no output to STDOUT' "[ -s '${stdoutF}' ]" |
| 157 | assertTrue 'expected output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 158 | done |
| 159 | } |
| 160 | |
| 161 | testValidIntegers() |
| 162 | { |
| 163 | _testValidIntegers '-i' |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 164 | flags_getoptIsEnh || return |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 165 | _testValidIntegers '--int' |
| 166 | } |
| 167 | |
| 168 | _testValidIntegers() |
| 169 | { |
| 170 | flag=$1 |
| 171 | for value in ${TH_INT_VALID}; do |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 172 | FLAGS ${flag} ${value} >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 173 | r3turn=$? |
| 174 | assertTrue "FLAGS (${value}) returned a non-zero result (${r3turn})" ${r3turn} |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 175 | assertEquals "integer (${value}) test failed." ${value} ${FLAGS_int} |
kate.ward | e556cbf | 2008-11-13 00:41:59 +0000 | [diff] [blame] | 176 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 177 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 178 | done |
| 179 | } |
| 180 | |
| 181 | testInvalidIntegers() |
| 182 | { |
| 183 | _testInvalidIntegers '-i' |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 184 | flags_getoptIsEnh || return |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 185 | _testInvalidIntegers '--int' |
| 186 | } |
| 187 | |
| 188 | _testInvalidIntegers() |
| 189 | { |
| 190 | flag=$1 |
| 191 | for value in ${TH_INT_INVALID}; do |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 192 | th_clearReturn |
| 193 | ( |
| 194 | FLAGS ${flag} ${value} >"${stdoutF}" 2>"${stderrF}" |
| 195 | echo $? >"${returnF}" |
| 196 | ) |
| 197 | th_queryReturn |
| 198 | assertFalse "invalid integer (${value}) test returned success." ${th_return} |
kate.ward | e10dd53 | 2013-01-04 21:52:23 +0000 | [diff] [blame] | 199 | assertFalse 'expected no output to STDOUT' "[ -s '${stdoutF}' ]" |
| 200 | assertTrue 'expected output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 201 | done |
| 202 | } |
| 203 | |
| 204 | testValidStrings() |
| 205 | { |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 206 | _testValidStrings -s single_word |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 207 | if flags_getoptIsEnh; then |
| 208 | _testValidStrings --str single_word |
| 209 | _testValidStrings --str 'string with spaces' |
| 210 | fi |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | _testValidStrings() |
| 214 | { |
| 215 | flag=$1 |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 216 | value=$2 |
| 217 | |
| 218 | FLAGS ${flag} "${value}" >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 219 | r3turn=$? |
| 220 | assertTrue "'FLAGS ${flag} ${value}' returned a non-zero result (${r3turn})" \ |
| 221 | ${r3turn} |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 222 | assertEquals "string (${value}) test failed." "${value}" "${FLAGS_str}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 223 | if [ ${r3turn} -eq ${FLAGS_TRUE} ]; then |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 224 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
| 225 | else |
| 226 | # validate that an error is thrown for unsupported getopt uses |
| 227 | assertFatalMsg '.* spaces in options' |
| 228 | fi |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 229 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | testMultipleFlags() |
| 233 | { |
| 234 | _testMultipleFlags '-b' '-i' '-f' '-s' |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 235 | flags_getoptIsEnh || return |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 236 | _testMultipleFlags '--bool' '--int' '--float' '--str' |
| 237 | } |
| 238 | |
| 239 | _testMultipleFlags() |
| 240 | { |
| 241 | boolFlag=$1 |
| 242 | intFlag=$2 |
| 243 | floatFlag=$3 |
| 244 | strFlag=$4 |
| 245 | |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 246 | FLAGS \ |
| 247 | ${boolFlag} \ |
| 248 | ${intFlag} 567 \ |
| 249 | ${floatFlag} 123.45678 \ |
| 250 | ${strFlag} 'some_string' \ |
| 251 | >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 252 | r3turn=$? |
| 253 | assertTrue "use of multple flags returned a non-zero result" ${r3turn} |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 254 | assertTrue 'boolean test failed.' ${FLAGS_bool} |
| 255 | assertNotSame 'float test failed.' 0 ${FLAGS_float} |
| 256 | assertNotSame 'integer test failed.' 0 ${FLAGS_int} |
| 257 | assertNotSame 'string test failed.' '' ${FLAGS_str} |
kate.ward | e556cbf | 2008-11-13 00:41:59 +0000 | [diff] [blame] | 258 | assertFalse 'expected no output to STDERR' "[ -s '${stderrF}' ]" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 259 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | _testNonFlagArgs() |
| 263 | { |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 264 | argc=$1 |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 265 | shift |
| 266 | |
kate.ward | 812aeae | 2009-04-01 02:49:51 +0000 | [diff] [blame] | 267 | FLAGS "$@" >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 268 | r3turn=$? |
| 269 | assertTrue 'parse returned non-zero value.' ${r3turn} |
| 270 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 271 | |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 272 | eval set -- "${FLAGS_ARGV}" |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 273 | assertEquals 'wrong count of argv arguments returned.' ${argc} $# |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 274 | assertEquals 'wrong count of argc arguments returned.' 0 ${FLAGS_ARGC} |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | testSingleNonFlagArg() |
| 278 | { |
| 279 | _testNonFlagArgs 1 argOne |
| 280 | } |
| 281 | |
| 282 | testMultipleNonFlagArgs() |
| 283 | { |
| 284 | _testNonFlagArgs 3 argOne argTwo arg3 |
| 285 | } |
| 286 | |
| 287 | testMultipleNonFlagStringArgsWithSpaces() |
| 288 | { |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 289 | flags_getoptIsEnh || return |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 290 | _testNonFlagArgs 3 argOne 'arg two' arg3 |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 291 | } |
| 292 | |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 293 | testFlagsWithEquals() |
| 294 | { |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 295 | flags_getoptIsEnh || return |
kate.ward | 812aeae | 2009-04-01 02:49:51 +0000 | [diff] [blame] | 296 | |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 297 | FLAGS --str='str_flag' 'non_flag' >"${stdoutF}" 2>"${stderrF}" |
| 298 | assertTrue 'FLAGS returned a non-zero result' $? |
| 299 | assertEquals 'string flag not set properly' 'str_flag' "${FLAGS_str}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 300 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 301 | |
| 302 | eval set -- "${FLAGS_ARGV}" |
| 303 | assertEquals 'wrong count of argv arguments returned.' 1 $# |
| 304 | assertEquals 'wrong count of argc arguments returned.' 1 ${FLAGS_ARGC} |
| 305 | } |
| 306 | |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 307 | testComplicatedCommandLineStandard() |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 308 | { |
kate.ward | 32d97fb | 2013-01-06 16:05:26 +0000 | [diff] [blame] | 309 | flags_getoptIsEnh && return |
| 310 | |
| 311 | # Note: standard getopt stops parsing after first non-flag argument, which |
| 312 | # results in the remaining flags being treated as arguments instead. |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 313 | FLAGS -i 1 non_flag_1 -s 'two' non_flag_2 -f 3 non_flag_3 \ |
| 314 | >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 315 | r3turn=$? |
| 316 | assertTrue 'FLAGS returned a non-zero result' ${r3turn} |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 317 | assertEquals 'failed int test' 1 ${FLAGS_int} |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 318 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 319 | |
| 320 | eval set -- "${FLAGS_ARGV}" |
kate.ward | 32d97fb | 2013-01-06 16:05:26 +0000 | [diff] [blame] | 321 | assertEquals 'incorrect number of argv values' 7 $# |
kate.ward | 812aeae | 2009-04-01 02:49:51 +0000 | [diff] [blame] | 322 | } |
| 323 | |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 324 | testComplicatedCommandLineEnhanced() |
kate.ward | 812aeae | 2009-04-01 02:49:51 +0000 | [diff] [blame] | 325 | { |
kate.ward | 20d9ef5 | 2013-01-06 15:56:46 +0000 | [diff] [blame] | 326 | flags_getoptIsEnh || return |
kate.ward | 812aeae | 2009-04-01 02:49:51 +0000 | [diff] [blame] | 327 | |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 328 | FLAGS -i 1 non_flag_1 --str='two' non_flag_2 --float 3 'non flag 3' \ |
| 329 | >"${stdoutF}" 2>"${stderrF}" |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 330 | r3turn=$? |
| 331 | assertTrue 'FLAGS returned a non-zero result' ${r3turn} |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 332 | assertEquals 'failed int test' 1 ${FLAGS_int} |
| 333 | assertEquals 'failed str test' 'two' "${FLAGS_str}" |
| 334 | assertEquals 'failed float test' 3 ${FLAGS_float} |
kate.ward | a2adce1 | 2013-01-15 00:00:39 +0000 | [diff] [blame] | 335 | th_showOutput ${r3turn} "${stdoutF}" "${stderrF}" |
kate.ward | 7a3c9c4 | 2009-04-24 00:12:35 +0000 | [diff] [blame] | 336 | |
| 337 | eval set -- "${FLAGS_ARGV}" |
| 338 | assertEquals 'incorrect number of argv values' 3 $# |
kate.ward | c521068 | 2009-03-30 18:54:36 +0000 | [diff] [blame] | 339 | } |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 340 | |
| 341 | #------------------------------------------------------------------------------ |
| 342 | # suite functions |
| 343 | # |
| 344 | |
| 345 | oneTimeSetUp() |
| 346 | { |
kate.ward | 1b600c5 | 2008-11-12 21:26:05 +0000 | [diff] [blame] | 347 | th_oneTimeSetUp |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 348 | |
kate.ward | 619806d | 2008-11-15 19:59:57 +0000 | [diff] [blame] | 349 | if flags_getoptIsStd; then |
| 350 | th_warn 'Standard version of getopt found. Enhanced tests will be skipped.' |
| 351 | else |
| 352 | th_warn 'Enhanced version of getopt found. Standard tests will be skipped.' |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 353 | fi |
| 354 | } |
| 355 | |
| 356 | setUp() |
| 357 | { |
kate.ward | 8fe62e6 | 2010-03-28 23:07:35 +0000 | [diff] [blame] | 358 | DEFINE_boolean bool false 'boolean test' 'b' |
kate.ward | 9ebdd16 | 2008-11-12 20:11:57 +0000 | [diff] [blame] | 359 | DEFINE_float float 0.0 'float test' 'f' |
| 360 | DEFINE_integer int 0 'integer test' 'i' |
| 361 | DEFINE_string str '' 'string test' 's' |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 362 | } |
| 363 | |
kate.ward | e10dd53 | 2013-01-04 21:52:23 +0000 | [diff] [blame] | 364 | tearDown() |
| 365 | { |
| 366 | flags_reset |
| 367 | } |
| 368 | |
kate.ward | f51c616 | 2008-06-17 16:38:35 +0000 | [diff] [blame] | 369 | # load and run shUnit2 |
| 370 | [ -n "${ZSH_VERSION:-}" ] && SHUNIT_PARENT=$0 |
| 371 | . ${TH_SHUNIT} |