#!/bin/bash
# -*- shell-script -*-

# Test _Dbg_file_canonic
proc test_file_file_canonic
{
    global _Dbg_set_basename := '0'
    for file in [/tmp/foo.bar /a/b/foo.bar foo.bar]  {
	typeset canonic_file
	global canonic_file := $[_Dbg_file_canonic $file]
	assertEquals 'canonic_file should return 0' '0' $Status
	assertEquals 'canonic_file should do nothing' $file $canonic_file
    }

    global _Dbg_set_basename := '1'
    typeset canonic_file
    for file in [/tmp/foo.bar /a/b/foo.bar foo.bar]  {
	global canonic_file := $[_Dbg_file_canonic $file]
	assertEquals 'canonic_file should return 0' '0' $Status
	assertEquals 'canonic_file should shorten file' 'foo.bar' $canonic_file
    }
    global canonic_file := $[_Dbg_file_canonic]
    assertNotEquals 'canonic_file not should return 0' '0' $Status
    # Other tests need _Dbg_set_basename = 0
    global _Dbg_set_basename := '0'
}

# Test _Dbg_tilde_expand_filename
proc test_file_glob_filename
{
    typeset filename

    global filename := ''''
    _Dbg_tilde_expand_filename $shunit_file
    assertEquals '0' $Status
    global filename := $(filename##*/)
    assertEquals 'shunit2' $filename

    _Dbg_tilde_expand_filename ./$(srcdir)shunit?
    assertEquals '0' $Status
    global filename := $(filename##*/)
    assertEquals 'shunit2' $filename

    _Dbg_tilde_expand_filename ./$(srcdir)[a-s]h*nit?
    assertEquals '0' $Status
    global filename := $(filename##*/)
    assertEquals 'shunit2' $filename

    _Dbg_tilde_expand_filename $(srcdir)abcdefg
    assertEquals '1' $Status
    global filename := $(filename##*/)
    assertEquals 'abcdefg' $filename

    if [[ -r ~ ]]  {
	_Dbg_tilde_expand_filename '~'
	assertEquals '0' $Status
	assertEquals ~ $filename
    }

    _Dbg_tilde_expand_filename $(srcdir)'some embedded spaces'
    assertEquals '1' $Status
    global filename := $(filename##*/)
    assertEquals 'some embedded spaces' $filename

}

# Test _Dbg_adjust_filename
proc test_file_adjust_filename
{
    typeset filename
    global _Dbg_set_annotate := '0'
    global _Dbg_set_basename := '0'
    global filename := $[_Dbg_adjust_filename abc]
    assertEquals 'abc' $filename
    global filename := $[_Dbg_adjust_filename /abc]
    assertEquals '/abc' $filename
    global _Dbg_set_basename := '1'
    global filename := $[_Dbg_adjust_filename /abc]
    assertEquals 'abc' $filename
}

# Test _Dbg_tilde_expand_filename
proc test_file_resolve_expand_filename
{
    global filename := $[_Dbg_resolve_expand_filename /]
    assertEquals '0' $Status
    assertEquals '/' $filename
    global filename := $[_Dbg_resolve_expand_filename .]
    assertEquals '0' $Status
    assertEquals '/' $(filename:0:1)
    global filename := $[_Dbg_resolve_expand_filename ./fdafdsa]
    assertEquals '0' $Status
    typeset -i size=$(#filename)
    assertEquals '/fdafdsa' $(filename:$size-8)
    assertNotEquals '.' $(filename:$size-1)
}

global abs_top_srcdir := '/src/external-vcs/sourceforge/bashdb'
# Make sure $abs_top_srcrdir has a trailing slash
global abs_top_srcdir := "$(abs_top_srcdir%%/)/"
source ${abs_top_srcdir}test/unit/helper.sh

global srcdir := '.'
global srcdir := "$(srcdir%%/)/"

source $abs_top_srcdir/init/pre.sh
source $abs_top_srcdir/lib/filecache.sh
source $abs_top_srcdir/lib/file.sh

set -- # reset $# so shunit2 doesn't get confused.

[[ $0 == ${BASH_SOURCE} ]] && source ${shunit_file}
(CommandList
  children: [
    (FuncDef
      name: test_file_file_canonic
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_set_basename)
                  op: Equal
                  rhs: {(0)}
                  spids: [17]
                )
              ]
              spids: [17]
            )
            (ForEach
              iter_name: file
              iter_words: [{(/tmp/foo.bar)} {(/a/b/foo.bar)} {(foo.bar)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(typeset)} {(canonic_file)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:canonic_file)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(_Dbg_file_canonic)} {(DQ ($ VSub_Name "$file"))})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [44 50]
                              )
                            }
                          spids: [43]
                        )
                      ]
                      spids: [43]
                    )
                    (C {(assertEquals)} {(SQ <"canonic_file should return 0">)} {(SQ <0>)} 
                      {($ VSub_QMark "$?")}
                    )
                    (C {(assertEquals)} {(SQ <"canonic_file should do nothing">)} 
                      {(DQ ($ VSub_Name "$file"))} {(DQ ($ VSub_Name "$canonic_file"))}
                    )
                  ]
                  spids: [35 81]
                )
              spids: [26 33]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_set_basename)
                  op: Equal
                  rhs: {(1)}
                  spids: [85]
                )
              ]
              spids: [85]
            )
            (C {(typeset)} {(canonic_file)})
            (ForEach
              iter_name: file
              iter_words: [{(/tmp/foo.bar)} {(/a/b/foo.bar)} {(foo.bar)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:canonic_file)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(_Dbg_file_canonic)} {(DQ ($ VSub_Name "$file"))})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [112 118]
                              )
                            }
                          spids: [111]
                        )
                      ]
                      spids: [111]
                    )
                    (C {(assertEquals)} {(SQ <"canonic_file should return 0">)} {(SQ <0>)} 
                      {($ VSub_QMark "$?")}
                    )
                    (C {(assertEquals)} {(SQ <"canonic_file should shorten file">)} {(SQ <foo.bar>)} 
                      {(DQ ($ VSub_Name "$canonic_file"))}
                    )
                  ]
                  spids: [108 149]
                )
              spids: [99 106]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:canonic_file)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_Dbg_file_canonic)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [153 155]
                      )
                    }
                  spids: [152]
                )
              ]
              spids: [152]
            )
            (C {(assertNotEquals)} {(SQ <"canonic_file not should return 0">)} {(SQ <0>)} 
              {($ VSub_QMark "$?")}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_set_basename)
                  op: Equal
                  rhs: {(0)}
                  spids: [175]
                )
              ]
              spids: [175]
            )
          ]
          spids: [14]
        )
      spids: [10 13]
    )
    (FuncDef
      name: test_file_glob_filename
      body: 
        (BraceGroup
          children: [
            (C {(typeset)} {(filename)})
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:filename) op:Equal rhs:{(SQ )} spids:[197])]
              spids: [197]
            )
            (C {(_Dbg_tilde_expand_filename)} {($ VSub_Name "$shunit_file")})
            (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name filename>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                        spids: [217 222]
                      )
                    }
                  spids: [216]
                )
              ]
              spids: [216]
            )
            (C {(assertEquals)} {(SQ <shunit2>)} {($ VSub_Name "$filename")})
            (C {(_Dbg_tilde_expand_filename)} {(./) (${ VSub_Name srcdir) (shunit) (Lit_Other "?")})
            (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name filename>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                        spids: [255 260]
                      )
                    }
                  spids: [254]
                )
              ]
              spids: [254]
            )
            (C {(assertEquals)} {(SQ <shunit2>)} {($ VSub_Name "$filename")})
            (C {(_Dbg_tilde_expand_filename)} 
              {(./) (${ VSub_Name srcdir) (Lit_Other "[") (a-s) (Lit_Other "]") (h) (Lit_Other "*") (nit) 
                (Lit_Other "?")
              }
            )
            (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name filename>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                        spids: [298 303]
                      )
                    }
                  spids: [297]
                )
              ]
              spids: [297]
            )
            (C {(assertEquals)} {(SQ <shunit2>)} {($ VSub_Name "$filename")})
            (C {(_Dbg_tilde_expand_filename)} {(${ VSub_Name srcdir) (abcdefg)})
            (C {(assertEquals)} {(SQ <1>)} {($ VSub_QMark "$?")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name filename>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                        spids: [334 339]
                      )
                    }
                  spids: [333]
                )
              ]
              spids: [333]
            )
            (C {(assertEquals)} {(SQ <abcdefg>)} {(DQ ($ VSub_Name "$filename"))})
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (DBracket expr:(BoolUnary op_id:BoolUnary_r child:{(Lit_Tilde "~")}))
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(_Dbg_tilde_expand_filename)} {(SQ <"~">)})
                    (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
                    (C {(assertEquals)} {(TildeSubPart prefix:"")} {(DQ ($ VSub_Name "$filename"))})
                  ]
                  spids: [-1 366]
                )
              ]
              spids: [-1 394]
            )
            (C {(_Dbg_tilde_expand_filename)} {(${ VSub_Name srcdir) (SQ <"some embedded spaces">)})
            (C {(assertEquals)} {(SQ <1>)} {($ VSub_QMark "$?")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name filename>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                        spids: [418 423]
                      )
                    }
                  spids: [417]
                )
              ]
              spids: [417]
            )
            (C {(assertEquals)} {(SQ <"some embedded spaces">)} {(DQ ($ VSub_Name "$filename"))})
          ]
          spids: [188]
        )
      spids: [184 187]
    )
    (FuncDef
      name: test_file_adjust_filename
      body: 
        (BraceGroup
          children: [
            (C {(typeset)} {(filename)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_set_annotate)
                  op: Equal
                  rhs: {(0)}
                  spids: [455]
                )
              ]
              spids: [455]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_set_basename)
                  op: Equal
                  rhs: {(0)}
                  spids: [459]
                )
              ]
              spids: [459]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_Dbg_adjust_filename)} {(abc)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [464 468]
                      )
                    }
                  spids: [463]
                )
              ]
              spids: [463]
            )
            (C {(assertEquals)} {(SQ <abc>)} {($ VSub_Name "$filename")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_Dbg_adjust_filename)} {(/abc)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [481 485]
                      )
                    }
                  spids: [480]
                )
              ]
              spids: [480]
            )
            (C {(assertEquals)} {(SQ </abc>)} {($ VSub_Name "$filename")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_Dbg_set_basename)
                  op: Equal
                  rhs: {(1)}
                  spids: [497]
                )
              ]
              spids: [497]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(_Dbg_adjust_filename)} {(/abc)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [502 506]
                      )
                    }
                  spids: [501]
                )
              ]
              spids: [501]
            )
            (C {(assertEquals)} {(SQ <abc>)} {($ VSub_Name "$filename")})
          ]
          spids: [447]
        )
      spids: [443 446]
    )
    (FuncDef
      name: test_file_resolve_expand_filename
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_Dbg_resolve_expand_filename)} {(/)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [531 535]
                      )
                    }
                  spids: [530]
                )
              ]
              spids: [530]
            )
            (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
            (C {(assertEquals)} {(SQ </>)} {(DQ ($ VSub_Name "$filename"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_Dbg_resolve_expand_filename)} {(.)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [559 563]
                      )
                    }
                  spids: [558]
                )
              ]
              spids: [558]
            )
            (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
            (C {(assertEquals)} {(SQ </>)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name filename>
                    suffix_op: 
                      (Slice
                        begin: (ArithWord w:{(Lit_Digits 0)})
                        length: (ArithWord w:{(Lit_Digits 1)})
                      )
                    spids: [582 588]
                  )
                )
              }
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filename)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(_Dbg_resolve_expand_filename)} {(./fdafdsa)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [593 597]
                      )
                    }
                  spids: [592]
                )
              ]
              spids: [592]
            )
            (C {(assertEquals)} {(SQ <0>)} {($ VSub_QMark "$?")})
            (C {(typeset)} {(-i)} 
              {(Lit_VarLike "size=") 
                (BracedVarSub
                  token: <VSub_Name filename>
                  prefix_op: VSub_Pound
                  spids: [614 617]
                )
              }
            )
            (C {(assertEquals)} {(SQ </fdafdsa>)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name filename>
                    suffix_op: 
                      (Slice
                        begin: 
                          (ArithBinary
                            op_id: Arith_Minus
                            left: (ArithWord w:{($ VSub_Name "$size")})
                            right: (ArithWord w:{(Lit_Digits 8)})
                          )
                      )
                    spids: [627 633]
                  )
                )
              }
            )
            (C {(assertNotEquals)} {(SQ <.>)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name filename>
                    suffix_op: 
                      (Slice
                        begin: 
                          (ArithBinary
                            op_id: Arith_Minus
                            left: (ArithWord w:{($ VSub_Name "$size")})
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                      )
                    spids: [644 650]
                  )
                )
              }
            )
          ]
          spids: [527]
        )
      spids: [523 526]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:abs_top_srcdir)
          op: Equal
          rhs: {(/src/external-vcs/sourceforge/bashdb)}
          spids: [656]
        )
      ]
      spids: [656]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:abs_top_srcdir)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name abs_top_srcdir>
                suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{(Lit_Slash /)})
                spids: [663 667]
              ) (/)
            }
          spids: [662]
        )
      ]
      spids: [662]
    )
    (C {(.)} {(${ VSub_Name abs_top_srcdir) (test/unit/helper.sh)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:srcdir) op:Equal rhs:{(.)} spids:[678])]
      spids: [678]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:srcdir)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name srcdir>
                suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{(Lit_Slash /)})
                spids: [682 686]
              ) (/)
            }
          spids: [681]
        )
      ]
      spids: [681]
    )
    (C {(.)} {($ VSub_Name "$abs_top_srcdir") (/init/pre.sh)})
    (C {(.)} {($ VSub_Name "$abs_top_srcdir") (/lib/filecache.sh)})
    (C {(.)} {($ VSub_Name "$abs_top_srcdir") (/lib/file.sh)})
    (C {(set)} {(--)})
    (AndOr
      children: [
        (DBracket
          expr: 
            (BoolBinary
              op_id: BoolBinary_GlobDEqual
              left: {($ VSub_Number "$0")}
              right: {(${ VSub_Name BASH_SOURCE)}
            )
        )
        (C {(.)} {(${ VSub_Name shunit_file)})
      ]
      op_id: Op_DAmp
    )
  ]
)