#!/bin/sh

cd $(0%/*)

# Can't detect sourcing in sh, so immediately terminate the attempt to parse
source ../JSON.sh </dev/null

proc ptest {
  tokenize | parse >/dev/null
}

global fails := '0'
global i := '0'
echo "1..4"
for input in ['"oooo"  ' '[true, 1, [0, {}]]  ' '{"true": 1}]'
{
  global i := $(i+1)
  if echo $input | ptest 
  {
    echo "ok $i - $input"
  } else {
    echo "not ok $i - $input"
    global fails := $(fails+1)
  }
}

if ! ptest < ../package.json
{
  echo "not ok 4 - Parsing package.json failed!"
  global fails := $(fails+1)
} else { 
  echo "ok $i - package.json"
}

echo "$fails test(s) failed"
exit $fails
(CommandList
  children: [
    (C {(cd)} 
      {
        (BracedVarSub
          token: <VSub_Number 0>
          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ("*")})
          spids: [6 11]
        )
      }
    )
    (SimpleCommand
      words: [{(.)} {(../JSON.sh)}]
      redirects: [(Redir op_id:Redir_Less fd:-1 arg_word:{(/dev/null)} spids:[21])]
    )
    (FuncDef
      name: ptest
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(tokenize)})
                (SimpleCommand
                  words: [{(parse)}]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[39])]
                )
              ]
              negated: False
            )
          ]
          spids: [30]
        )
      spids: [25 29]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:fails) op:Equal rhs:{(0)} spids:[45])]
      spids: [45]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:i) op:Equal rhs:{(0)} spids:[48])]
      spids: [48]
    )
    (C {(echo)} {(DQ (1..4))})
    (ForEach
      iter_name: input
      iter_words: [{(SQ <"\"oooo\"  ">)} {(SQ <"[true, 1, [0, {}]]  ">)} {(SQ <"{\"true\": 1}">)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:i)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithVarRef name:i)
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [79 84]
                      )
                    }
                  spids: [78]
                )
              ]
              spids: [78]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Pipeline
                      children: [(C {(echo)} {(DQ ($ VSub_Name "$input"))}) (C {(ptest)})]
                      negated: False
                    )
                  ]
                  action: [(C {(echo)} {(DQ ("ok ") ($ VSub_Name "$i") (" - ") ($ VSub_Name "$input"))})]
                  spids: [-1 101]
                )
              ]
              else_action: [
                (C {(echo)} {(DQ ("not ok ") ($ VSub_Name "$i") (" - ") ($ VSub_Name "$input"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:fails)
                      op: Equal
                      rhs: 
                        {
                          (ArithSubPart
                            anode: 
                              (ArithBinary
                                op_id: Arith_Plus
                                left: (ArithVarRef name:fails)
                                right: (ArithWord w:{(Lit_Digits 1)})
                              )
                            spids: [128 133]
                          )
                        }
                      spids: [127]
                    )
                  ]
                  spids: [127]
                )
              ]
              spids: [114 136]
            )
          ]
          spids: [75 138]
        )
      spids: [62 -1]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [{(ptest)}]
                  redirects: [(Redir op_id:Redir_Less fd:-1 arg_word:{(../package.json)} spids:[147])]
                )
              ]
              negated: True
            )
          ]
          action: [
            (C {(echo)} {(DQ ("not ok 4 - Parsing package.json failed!"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fails)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithVarRef name:fails)
                            right: (ArithWord w:{(Lit_Digits 1)})
                          )
                        spids: [162 167]
                      )
                    }
                  spids: [161]
                )
              ]
              spids: [161]
            )
          ]
          spids: [-1 151]
        )
      ]
      else_action: [(C {(echo)} {(DQ ("ok ") ($ VSub_Name "$i") (" - package.json"))})]
      spids: [169 181]
    )
    (C {(echo)} {(DQ ($ VSub_Name "$fails") (" test(s) failed"))})
    (C {(exit)} {($ VSub_Name "$fails")})
  ]
)