#! /bin/sh
# vim:et:ft=sh:sts=2:sw=2
#
# shFlags unit tests for the internal functions.
#
#
# Copyright 2008-2017 Kate Ward. All Rights Reserved.
# Released under the Apache 2.0 license.
#
# Author: kate.ward@forestent.com (Kate Ward)
# https://github.com/kward/shflags
#
### ShellCheck (http://www.shellcheck.net/)
# Disable source following.
#   shellcheck disable=SC1090,SC1091
# expr may be antiquated, but it is the only solution in some cases.
#   shellcheck disable=SC2003
# $() are not fully portable (POSIX != portable).
#   shellcheck disable=SC2006

# These variables will be overridden by the test helpers.
setglobal stdoutF = ""$(TMPDIR:-/tmp)/STDOUT""
setglobal stderrF = ""$(TMPDIR:-/tmp)/STDERR""

# Load test helpers.
source ./shflags_test_helpers

proc testColumns {
  setglobal cols = $[_flags_columns]
  setglobal value = $[expr $(cols) : '\([0-9]*\)]
  assertNotNull "unexpected screen width ($(cols))" $(value)
}

proc testGetoptVers {
  # shellcheck disable=SC2162
  while read desc mock want {
    assertEquals $(desc) $[_flags_getopt_vers $(mock)] $(want)
  } <<EOF
standard mock_getopt_std ${__FLAGS_GETOPT_VERS_STD}
enhanced mock_getopt_enh ${__FLAGS_GETOPT_VERS_ENH}
EOF
}

### The mock_getopt_* commands behave like "getopt -lfoo '' --foo" was called.
# macOS 10.13.0.
proc mock_getopt_std { echo ' -- --foo'; return 0; }
# Ubuntu 16.04.3
proc mock_getopt_enh { echo ' --foo --'; return 0; }

proc testGenOptStr {
  _testGenOptStr '' ''

  DEFINE_boolean bool false 'boolean value' b
  _testGenOptStr 'b' 'bool'

  DEFINE_float float 0.0 'float value' f
  _testGenOptStr 'bf:' 'bool,float:'

  DEFINE_integer int 0 'integer value' i
  _testGenOptStr 'bf:i:' 'bool,float:,int:'

  DEFINE_string str 0 'string value' s
  _testGenOptStr 'bf:i:s:' 'bool,float:,int:,str:'

  DEFINE_boolean help false 'show help' h
  _testGenOptStr 'bf:i:s:h' 'bool,float:,int:,str:,help'
}

proc _testGenOptStr {
  setglobal short = $1
  setglobal long = $2

  setglobal result = $[_flags_genOptStr $(__FLAGS_OPTSTR_SHORT)]
  assertTrue 'short option string generation failed' $Status
  assertEquals $(short) $(result)

  setglobal result = $[_flags_genOptStr $(__FLAGS_OPTSTR_LONG)]
  assertTrue 'long option string generation failed' $Status
  assertEquals $(long) $(result)
}

proc testGetFlagInfo {
  setglobal __flags_blah_foobar = ''1234''

  setglobal rslt = $[_flags_getFlagInfo 'blah' 'foobar]
  assertTrue 'request for valid flag info failed' $Status
  assertEquals 'invalid flag info returned' $(__flags_blah_foobar) $(rslt)

  setglobal rslt = $[_flags_getFlagInfo 'blah' 'hubbabubba' >$(stdoutF) !2 >$(stderrF)]
  assertEquals 'invalid flag did not result in an error' $(FLAGS_ERROR) $Status
  assertErrorMsg 'missing flag info variable'
}

proc testItemInList {
  setglobal list = ''this is a test''
  # shellcheck disable=SC2162
  while read desc item want {
    _flags_itemInList $(item) $(list)
    setglobal got = $Status
    assertEquals "$(desc): itemInList($(item))" $(got) $(want)
  } <<EOF
lead_item       this  ${FLAGS_TRUE}
middle_item     is    ${FLAGS_TRUE}
last_item       test  ${FLAGS_TRUE}
missing_item    asdf  ${FLAGS_FALSE}
test_partial_te te    ${FLAGS_FALSE}
test_partial_es es    ${FLAGS_FALSE}
test_partial_st st    ${FLAGS_FALSE}
empty_item      ''    ${FLAGS_FALSE}
EOF

  _flags_itemInList 'item' ''
  assertFalse 'empty lists should not match' $Status
}

proc testValidBool {
  # Valid values.
  for value in [$(TH_BOOL_VALID)] {
    _flags_validBool $(value)
    assertTrue "valid value ($(value)) did not validate" $Status
  }

  # Invalid values.
  for value in [$(TH_BOOL_INVALID)] {
    _flags_validBool $(value)
    assertFalse "invalid value ($(value)) validated" $Status
  }
}

proc _testValidFloat {
  # Valid values.
  for value in [$(TH_INT_VALID) $(TH_FLOAT_VALID)] {
    _flags_validFloat $(value)
    assertTrue "valid value ($(value)) did not validate" $Status
  }

  # Invalid values.
  for value in [$(TH_FLOAT_INVALID)] {
    _flags_validFloat $(value)
    assertFalse "invalid value ($(value)) validated" $Status
  }
}

proc testValidFloatBuiltin {
  _flags_useBuiltin || startSkipping
  _testValidFloat
}

proc testValidFloatExpr {
  shell {
    proc _flags_useBuiltin { return "${FLAGS_FALSE}"; }
    _testValidFloat
  }
}

proc _testValidInt {
  # Valid values.
  for value in [$(TH_INT_VALID)] {
    _flags_validInt $(value)
    assertTrue "valid value ($(value)) did not validate" $Status
  }

  # Invalid values.
  for value in [$(TH_INT_INVALID)] {
    _flags_validInt $(value)
    assertFalse "invalid value ($(value)) should not validate" $Status
  }
}

proc testValidIntBuiltin {
  _flags_useBuiltin || startSkipping
  _testValidInt
}

proc testValidIntExpr {
  shell {
    proc _flags_useBuiltin { return "${FLAGS_FALSE}"; }
    _testValidInt
  }
}

proc _testMath {
  setglobal result = $[_flags_math 1]
  assertTrue '1 failed' $Status
  assertEquals '1' 1 $(result)

  setglobal result = $[_flags_math '1 + 2]
  assertTrue '1+2 failed' $Status
  assertEquals '1+2' 3 $(result)

  setglobal result = $[_flags_math '1 + 2 + 3]
  assertTrue '1+2+3 failed' $Status
  assertEquals '1+2+3' 6 $(result)

  setglobal result = $[_flags_math]
  assertFalse 'missing math succeeded' $Status
}

proc testMathBuiltin {
  _flags_useBuiltin || startSkipping
  _testMath
}

proc testMathExpr {
  shell {
    proc _flags_useBuiltin { return "${FLAGS_FALSE}"; }
    _testMath
  }
}

proc _testStrlen {
  setglobal len = $[_flags_strlen]
  assertTrue 'missing argument failed' $Status
  assertEquals 'missing argument' 0 $(len)

  setglobal len = $[_flags_strlen ]
  assertTrue 'empty argument failed' $Status
  assertEquals 'empty argument' 0 $(len)

  setglobal len = $[_flags_strlen abc123]
  assertTrue 'single-word failed' $Status
  assertEquals 'single-word' 6 $(len)

  setglobal len = $[_flags_strlen 'This is a test]
  assertTrue 'multi-word failed' $Status
  assertEquals 'multi-word' 14 $(len)
}

proc testStrlenBuiltin {
  _flags_useBuiltin || startSkipping
  _testStrlen
}

proc testStrlenExpr {
  shell {
    proc _flags_useBuiltin { return "${FLAGS_FALSE}"; }
    _testStrlen
  }
}

proc oneTimeSetUp {
  th_oneTimeSetUp

  _flags_useBuiltin || \
    th_warn 'Shell built-ins not supported. Some tests will be skipped.'
}

proc tearDown {
  flags_reset
}

# Load and run shUnit2.
# shellcheck disable=SC2034
test -n $(ZSH_VERSION:-) && setglobal SHUNIT_PARENT = $0
source "${TH_SHUNIT}"