# file      : tests/function/path/testscript
# license   : MIT; see accompanying LICENSE file

.include ../../common.testscript

s = ($cxx.target.class != 'windows' ? '/' : '\')

: canonicalize
:
{
  $* <'print $canonicalize([path] a/b)'           >"a$(s)b"            : path
  $* <'print $canonicalize([paths] a/b a/c)'      >"a$(s)b a$(s)c"     : paths
  $* <'print $canonicalize([dir_path] a/b)'       >"a$(s)b$s"          : dir-path
  $* <'print $canonicalize([dir_paths] a/b a/c/)' >"a$(s)b$s a$(s)c$s" : dir-paths
  $* <'print $path.canonicalize(a/b)'             >"a$(s)b"            : untyped
  $* <'print $path.canonicalize(a/b/ a/c)'        >"a$(s)b$s a$(s)c"   : mixed
}

: normalize
:
{
  $* <'print $normalize([path] a/../b)'              >"b"        : path
  $* <'print $normalize([paths] a/../b a/../c)'      >"b c"      : paths
  $* <'print $normalize([dir_path] a/../b)'          >"b$s"      : dir-path
  $* <'print $normalize([dir_paths] a/../b a/../c/)' >"b$s c$s"  : dir-paths
  $* <'print $path.normalize(a/../b)'                >"b"        : untyped
  $* <'print $path.normalize(a/../b/ a/../c)'        >"b$s c"    : mixed

  : actualize
  :
  if ($cxx.target.class == 'windows')
  {
    mkdir Foo;
    $* <'print $path.normalize($out_base/foo, true)' >~'/.+\\Foo/'
  }
}

: directory
:
{
  $* <'print $directory([path] a/b)'           >"a/"    : path
  $* <'print $directory([dir_path] a/b)'       >"a/"    : dir-path
  $* <'print $directory([paths] a/b c/d/)'     >"a/ c/" : paths
  $* <'print $directory([dir_paths] a/b c/d/)' >"a/ c/" : dir-paths
  $* <'print $path.directory(a/b c/d/)'        >"a/ c/" : dir-names
}

: base
:
{
  $* <'print $base([path] a.c)'               >"a"      : path
  $* <'print $base([dir_path] a.tmp)'         >"a$s"    : dir-path
  $* <'print $base([paths] a.c b.tmp/)'       >"a b/"   : paths
  $* <'print $base([dir_paths] a.tmp b.tmp/)' >"a$s b/" : dir-paths
  $* <'print $path.base(a.c b.tmp/)'          >"a b/"   : dir-names
}

: leaf
:
{
  $* <'print $leaf([path] a/b)'                          >"b"        : path
  $* <'print $leaf([dir_path] a/b)'                      >"b$s"      : dir-path
  $* <'print $leaf([path] a/b/c, [dir_path] a)'          >"b/c"      : sub-path
  $* <'print $leaf([dir_path] a/b/c, [dir_path] a)'      >"b/c$s"    : sub-dir-path
  $* <'print $leaf([paths] a/b/c a/b/e, [dir_path] a/b)' >"c e"      : sub-paths
  $* <'print $leaf([dir_paths] a/b/c, [dir_path] a/b)'   >"c$s"      : sub-dir-paths
  $* <'print $path.leaf(a/b c/d/)'                       >"b d/"     : dir-names
  $* <'print $path.leaf(a/b/c a/b/d/, [dir_path] a)'     >"b/c b/d/" : sub-dir-names

  : not-prefix
  :
  $* <'print $leaf([path] a/b/c, [dir_path] a/d)' 2>>"EOE" != 0
  error: 'a/d$s' is not a prefix of 'a/b/c'
    <stdin>:1:8: info: while calling leaf\(path, dir_path\)
  EOE
}

: extension
:
{
  $* <'print $extension([path] a.c)'        >"c"      : path
  $* <'print $extension([dir_path] a.tmp/)' >"tmp"    : dir_path
  $* <'print $path.extension(a.c)'          >"c"      : untyped
  $* <'print $path.extension(a)'            >"[null]" : null
}

: combined
:
{
  mkdir -p a/b;
  touch a/b/c.t.cpp;
  $* <<EOI >>/EOO
  t = $src_base/a/b/c.t.cpp
  d = $path.leaf($path.directory($t), $src_base)
  n = $path.base($path.base($path.leaf($t)))
  print $d/exe{$n}
  print $d/{+$n*.cpp}
  EOI
  a/b/exe{c}
  a/b/c.t.cpp
  EOO
}

: invalid-path
:
p = ($cxx.target.class != 'windows' ? /../foo : 'c:/../foo');
$* <"\$path.normalize\('$p')" 2>>"EOE" != 0
error: invalid path: '$p'
  <stdin>:1:2: info: while calling path.normalize\(<untyped>\)
EOE

: path-match
:
{
  : string
  :
  : Test overloads for at least one of the first two arguments being of the
  : string type.
  :
  {
    : string-string
    :
    $* <'print $path.match([string] "b", [string] "b*")' >'true'

    : untyped-string
    :
    $* <'print $path.match("b", [string] "b*")' >'true'

    : string-untyped
    :
    $* <'print $path.match([string] "b", "b*")' >'true'

    : path-string
    :
    $* <'print $match([path] "b", [string] "b*")' >'true'
  }

  : path
  :
  : Test overloads for at least one of the first two arguments being of the
  : path type.
  :
  {
    : path-path
    :
    $* <'print $match([path] "a/b", [path] "b**")' >'true'

    : path-untyped-untyped
    :
    $* <'print $match([path] "a/b", "b**", "$src_base")' >'true'

    : untyped-path
    :
    $* <'print $match("a/b", [path] "b**")' >'true'

    : untyped-path-dir
    :
    $* <'print $match("a/b", [path] "b**", $src_base)' >'true'

    : path-untyped
    :
    $* <'print $match([path] "a/b", "b**")' >'true'
  }

  : untyped
  :
  : Test overloads for the first two arguments being untyped.
  :
  {
    : converted-to-strings
    :
    $* <'print $path.match("b", "b**")' >'true'

    : converted-to-paths-due-to
    {
      : pattern
      :
      $* <'print $path.match("a/b/", "b**/")' >'true'

      : entry
      :
      $* <'print $path.match("a/b", "b**")' >'true'

      : start-dir
      :
      $* <'print $path.match("", "s***/", "$src_base")' >'true'
    }
  }
}