| #!/system/bin/sh |
| # |
| # Copyright 2015 Nest Labs, Inc. All rights reserved. |
| # |
| # This script essentially ports the test cases defined in |
| # test/CMakeLists.txt (which use CTest as the test runner). |
| |
| ### |
| ### Detect where the tests are installed, |
| ### typically /data/nativetest/google-gflags |
| ### |
| TEST_ROOT="$(dirname $0)" |
| grep -vE "^/" "$TEST_ROOT" &> /dev/null |
| if [ $? -eq 0 ] ; then |
| TEST_ROOT="$(pwd)/${TEST_ROOT}" |
| fi |
| |
| ### |
| ### GLOBAL VARIABLES |
| ### |
| ### only export variables that mutate |
| ### |
| |
| # Increment when a test passes |
| export GLOBAL_PASS=0 |
| # Increment when a test fails |
| export GLOBAL_FAIL=0 |
| # The os path separator, used to make copy/paste with CMakeLists.txt work |
| SLASH="/" |
| # The directory where helper test programs are installed |
| TEST_BIN="${TEST_ROOT}/bin" |
| # The directory where helper test data is installed |
| TEST_DATA="${TEST_ROOT}/data" |
| # The temporary directory where raw program output is placed |
| TMPDIR=/storage |
| # The log file with all raw program output |
| LOGFILE=$(mktemp --tmpdir="${TMPDIR}" google-gflags-unit-tests-log.XXXXXXXX) |
| # A temporary file, usually used for staging raw program output for grep |
| TMPFILE=$(mktemp --tmpdir="${TMPDIR}" google-gflags-unit-tests-tmp.XXXXXXXX) |
| |
| PATH="${TEST_BIN}:${PATH}" |
| |
| # run_test |
| # |
| # This is a /bin/sh port of add_gflags_test that is implemented by |
| # cmake/utils.cmake and cmake/execute_test.cmake |
| # |
| # Usage: run_test <test-name> <expected-return-code> <expected-text-output> <unexpected-text-output> <cmd> [args...] |
| # |
| # test-name: A symbolic name for the test for logging |
| # |
| # expected-return-code: the number passed back to the operating system. default: 0 |
| # if a blank string is given. |
| # |
| # expected-text-output: if a non-empty string, it is expected that the command will |
| # output this string. It must be seen in order to pass. |
| # |
| # unexpected-text-output: if a non-empty string, it is expected that the command |
| # will NOT output this string. If it is seen, the test will fail. |
| # |
| # cmd: executable to run (full path or in $PATH) |
| # |
| # args: all arguments that need to be passed on to the executable. |
| # |
| run_test() |
| { |
| TEST_NAME="$1" |
| shift |
| EXPECTED_RC="$1" |
| shift |
| EXPECTED_OUTPUT="$1" |
| shift |
| UNEXPECTED_OUTPUT="$1" |
| shift |
| |
| if [ $# -eq 0 ] ; then |
| GLOBAL_RETURN_CODE=1 |
| echo "FATAL ERROR: invalid arguments passed to run_test for test='$TEST_NAME'" |
| return 1 |
| fi |
| |
| if [ -z "$EXPECTED_RC" ] ; then |
| EXPECTED_RC="0" |
| fi |
| |
| VERDICT="pass" |
| REASON="default" |
| |
| echo "RUNNING TEST '${TEST_NAME}' >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" > "$TMPFILE" |
| echo "CMDLINE: $@" >> "$TMPFILE" |
| "$@" &>> "$TMPFILE" |
| RC=$? |
| echo "RC=$RC" >> "$TMPFILE" |
| echo "END OF TEST '${TEST_NAME}' <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" >> "$TMPFILE" |
| |
| EXPECTED_FOUND=1 |
| UNEXPECTED_FOUND=0 |
| |
| if [ -n "$EXPECTED_OUTPUT" ] ; then |
| grep -- "$EXPECTED_OUTPUT" "$TMPFILE" &> /dev/null |
| if [ $? -ne 0 ] ; then |
| EXPECTED_FOUND=0 |
| fi |
| fi |
| |
| if [ -n "$UNEXPECTED_OUTPUT" ] ; then |
| grep -- "$UNEXPECTED_OUTPUT" "$TMPFILE" &> /dev/null |
| if [ $? -eq 0 ] ; then |
| UNEXPECTED_FOUND=1 |
| fi |
| fi |
| |
| if [ "$RC" != "$EXPECTED_RC" ] ; then |
| VERDICT="fail" |
| REASON="unexpected return code (got ${RC}, expected ${EXPECTED_RC})" |
| elif [ "$EXPECTED_FOUND" = "0" ] ; then |
| VERDICT="fail" |
| REASON="missing expected output, expected '${EXPECTED_OUTPUT}', see '$LOGFILE'" |
| elif [ "$UNEXPECTED_FOUND" = "1" ] ; then |
| VERDICT="fail" |
| REASON="Unexpected output detected: '${UNEXPECTED_OUTPUT}', see '$LOGFILE'" |
| fi |
| |
| cat "$TMPFILE" >> "$LOGFILE" |
| |
| if [ "$VERDICT" = "pass" ] ; then |
| echo "${TEST_NAME}: pass" |
| GLOBAL_PASS=$(($GLOBAL_PASS + 1)) |
| return 0 |
| else |
| echo "${TEST_NAME}: fail ($REASON)" |
| GLOBAL_FAIL=$(($GLOBAL_FAIL + 1)) |
| return 1 |
| fi |
| } |
| |
| ### |
| ### TEST CASES |
| ### |
| ### These are mostly taken from test/CMakeLists.txt |
| ### |
| |
| cd "$TEST_ROOT" |
| |
| # Clear out the log file, add time |
| date > $LOGFILE |
| |
| echo LOGFILE=$LOGFILE | tee -a "$LOGFILE" |
| echo TMPFILE=$TMPFILE | tee -a "$LOGFILE" |
| |
| echo "SETTING ENVIRONMENT VARIABLES:" >> $LOGFILE |
| for N in FLAGS_undefok=foo,bar FLAGS_weirdo="" FLAGS_version="true" FLAGS_help="false" ; do |
| echo "$N" >> $LOGFILE |
| export $N |
| done |
| |
| # Test this script |
| run_test "the_truth" 0 "" "" true |
| run_test "the_lie" 1 "" "" false |
| run_test "the_word" "" "really unlikely" "" echo "really unlikely" |
| |
| # Make sure the --help output doesn't print the stripped text |
| run_test "strip_flags_help" 1 "" "This text should be stripped out" gflags_strip_flags_test --help |
| |
| # Make sure the stripped text isn't in the binary at all |
| strings "${TEST_BIN}/gflags_strip_flags_test" | grep "This text should be stripped out" |
| if [ $? -eq 0 ] ; then |
| echo "strip_flags_binary: fail (poison string detected)" |
| else |
| echo "strip_flags_binary: pass" |
| fi |
| |
| # First, just make sure the gflags_unittest works as-is |
| run_test "unittest" 0 "" "" gflags_unittest --test_tmpdir="${TMPDIR}" |
| |
| # --help should show all flags, including flags from gflags_reporting |
| run_test "help-reporting" 1 "${SLASH}gflags_reporting.cc:" "" gflags_unittest --help |
| |
| # Make sure that --help prints even very long helpstrings. |
| run_test long-helpstring 1 "end of a long helpstring" "" gflags_unittest --help |
| |
| # Make sure --help reflects flag changes made before flag-parsing |
| run_test changed_bool1 1 "-changed_bool1 (changed) type: bool default: true" "" gflags_unittest --help |
| run_test changed_bool2 1 "-changed_bool2 (changed) type: bool default: false currently: true" "" gflags_unittest --help |
| |
| # And on the command-line, too |
| run_test changeable_string_var 1 "-changeable_string_var () type: string default: \"1\" currently: \"2\"" "" gflags_unittest --changeable_string_var 2 --help |
| |
| # --nohelp and --help=false should be as if we didn't say anything |
| run_test nohelp 0 "PASS" "" gflags_unittest --nohelp |
| run_test help=false 0 "PASS" "" gflags_unittest --help=false |
| |
| # --helpfull is the same as help |
| run_test helpfull 1 "${SLASH}gflags_reporting.cc:" "" gflags_unittest --helpfull |
| |
| # --helpshort should show only flags from the gflags_unittest itself |
| run_test helpshort 1 "${SLASH}gflags_unittest.cc:" "${SLASH}gflags_reporting.cc:" gflags_unittest --helpshort |
| |
| # --helpshort should show the tldflag we created in the gflags_unittest dir |
| run_test helpshort-tldflag1 1 "tldflag1" "${SLASH}google.cc:" gflags_unittest --helpshort |
| run_test helpshort-tldflag2 1 "tldflag2" "${SLASH}google.cc:" gflags_unittest --helpshort |
| |
| # --helpshort should work if the main source file is suffixed with [_-]main |
| run_test helpshort-main 1 "${SLASH}gflags_unittest-main.cc:" "${SLASH}gflags_reporting.cc:" gflags_unittest-main --helpshort |
| run_test helpshort_main 1 "${SLASH}gflags_unittest_main.cc:" "${SLASH}gflags_reporting.cc:" gflags_unittest_main --helpshort |
| |
| # --helpon needs an argument |
| run_test helpon 1 "'--helpon' is missing its argument; flag description: show help on" "" gflags_unittest --helpon |
| # --helpon argument indicates what file we'll show args from |
| run_test helpon=gflags 1 "${SLASH}gflags.cc:" "${SLASH}gflags_unittest.cc:" gflags_unittest --helpon=gflags |
| # another way of specifying the argument |
| run_test helpon_gflags 1 "${SLASH}gflags.cc:" "${SLASH}gflags_unittest.cc:" gflags_unittest --helpon gflags |
| # test another argument |
| run_test helpon=gflags_unittest 1 "${SLASH}gflags_unittest.cc:" "${SLASH}gflags.cc:" gflags_unittest --helpon=gflags_unittest |
| |
| # helpmatch is like helpon but takes substrings |
| run_test helpmatch_reporting 1 "${SLASH}gflags_reporting.cc:" "${SLASH}gflags_unittest.cc:" gflags_unittest -helpmatch reporting |
| run_test helpmatch=unittest 1 "${SLASH}gflags_unittest.cc:" "${SLASH}gflags.cc:" gflags_unittest -helpmatch=unittest |
| |
| # if no flags are found with helpmatch or helpon, suggest --help |
| run_test helpmatch=nosuchsubstring 1 "No modules matched" "${SLASH}gflags_unittest.cc:" gflags_unittest -helpmatch=nosuchsubstring |
| run_test helpon=nosuchmodule 1 "No modules matched" "${SLASH}gflags_unittest.cc:" gflags_unittest -helpon=nosuchmodule |
| |
| # helppackage shows all the flags in the same dir as this unittest |
| # --help should show all flags, including flags from google.cc |
| run_test helppackage 1 "${SLASH}gflags_reporting.cc:" "" gflags_unittest --helppackage |
| |
| # xml! |
| run_test helpxml 1 "${SLASH}gflags_unittest.cc</file>" "${SLASH}gflags_unittest.cc:" gflags_unittest --helpxml |
| |
| # just print the version info and exit |
| run_test version-1 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:" gflags_unittest --version |
| run_test version-2 0 "version test_version" "${SLASH}gflags_unittest.cc:" gflags_unittest --version |
| |
| # --undefok is a fun flag... |
| run_test undefok-1 1 "unknown command line flag 'foo'" "" gflags_unittest --undefok= --foo --unused_bool |
| run_test undefok-2 0 "PASS" "" gflags_unittest --undefok=foo --foo --unused_bool |
| # If you say foo is ok to be undefined, we'll accept --nofoo as well |
| run_test undefok-3 0 "PASS" "" gflags_unittest --undefok=foo --nofoo --unused_bool |
| # It's ok if the foo is in the middle |
| run_test undefok-4 0 "PASS" "" gflags_unittest --undefok=fee,fi,foo,fum --foo --unused_bool |
| # But the spelling has to be just right... |
| run_test undefok-5 1 "unknown command line flag 'foo'" "" gflags_unittest --undefok=fo --foo --unused_bool |
| run_test undefok-6 1 "unknown command line flag 'foo'" "" gflags_unittest --undefok=foot --foo --unused_bool |
| |
| # See if we can successfully load our flags from the flagfile |
| run_test flagfile.1 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:" gflags_unittest "--flagfile=data/flagfile.1" |
| run_test flagfile.2 0 "PASS" "" gflags_unittest "--flagfile=data/flagfile.2" |
| run_test flagfile.3 0 "PASS" "" gflags_unittest "--flagfile=data/flagfile.3" |
| |
| # Also try to load flags from the environment |
| run_test fromenv=version 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:" gflags_unittest --fromenv=version |
| run_test tryfromenv=version 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:" gflags_unittest --tryfromenv=version |
| run_test fromenv=help 0 "PASS" "" gflags_unittest --fromenv=help |
| run_test tryfromenv=help 0 "PASS" "" gflags_unittest --tryfromenv=help |
| run_test fromenv=helpfull 1 "helpfull not found in environment" "" gflags_unittest --fromenv=helpfull |
| run_test tryfromenv=helpfull 0 "PASS" "" gflags_unittest --tryfromenv=helpfull |
| run_test tryfromenv=undefok 0 "PASS" "" gflags_unittest --tryfromenv=undefok --foo |
| run_test tryfromenv=weirdo 1 "unknown command line flag" "" gflags_unittest --tryfromenv=weirdo |
| run_test tryfromenv-multiple 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:" gflags_unittest --tryfromenv=test_bool,version,unused_bool |
| run_test fromenv=test_bool 1 "not found in environment" "" gflags_unittest --fromenv=test_bool |
| run_test fromenv=test_bool-ok 1 "unknown command line flag" "" gflags_unittest --fromenv=test_bool,ok |
| # Here, the --version overrides the fromenv |
| run_test version-overrides-fromenv 0 "gflags_unittest" "${SLASH}gflags_unittest.cc:" gflags_unittest --fromenv=test_bool,version,ok |
| |
| # Make sure -- by itself stops argv processing |
| run_test dashdash 0 "PASS" "" gflags_unittest -- --help |
| |
| # And we should die if the flag value doesn't pass the validator |
| run_test always_fail 1 "ERROR: failed validation of new value 'true' for flag 'always_fail'" "" gflags_unittest --always_fail |
| |
| run_test gflags_declare 0 "Hello gflags!" "" gflags_declare_test --message "Hello gflags!" |
| |
| if [ $GLOBAL_FAIL -ne 0 ] ; then |
| RETURN_CODE=1 |
| else |
| RETURN_CODE=0 |
| fi |
| TOTAL_TESTS=$(($GLOBAL_PASS + $GLOBAL_FAIL)) |
| |
| echo "${GLOBAL_PASS}/${TOTAL_TESTS} passed. See '$LOGFILE'" |
| rm "$TMPFILE" |
| |
| exit $RETURN_CODE |
