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