#!/bin/bash -eu
#
# Copyright 2015 The Bazel Authors. All rights reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and

# Integration tests for ijar zipper/unzipper


global DIR := $[cd $[dirname $(BASH_SOURCE[0])] && pwd]

## Inputs
global ZIPPER := "$(PWD)/$1"
shift
global UNZIP := $1
shift
global ZIP := $1
shift

## Test framework
source $(DIR)/testenv.sh || do { echo "testenv.sh not found!" > !2; exit 1; }

# Assertion
proc assert_unzip_same_as_zipper {
  var folder1 = $[mktemp -d $(TEST_TMPDIR)/output.XXXXXXXX]
  var folder2 = $[mktemp -d $(TEST_TMPDIR)/output.XXXXXXXX]
  var zipfile = $1
  shift
  shell {cd $folder1 && $UNZIP -q $zipfile $ifsjoin(Argv) || true}  # ignore CRC32 errors
  shell {cd $folder2 && $ZIPPER x $zipfile $ifsjoin(Argv)}
  diff -r $folder1 $folder2 &> $TEST_log \
      || fail "Unzip and Zipper resulted in different output"
}

proc assert_zipper_same_after_unzip {
  var dir = $1
  shift
  var zipfile = "$(TEST_TMPDIR)/output.zip"
  shell {cd $(dir) && $ZIPPER c $(zipfile) @Argv}
  var folder = $[mktemp -d $(TEST_TMPDIR)/output.XXXXXXXX]
  shell {cd $folder && $UNZIP -q $(zipfile) || true}  # ignore CRC32 errors
  diff -r $(dir) $folder &> $TEST_log \
      || fail "Unzip after zipper output differ"
  # Retry with compression
  shell {cd $(dir) && $ZIPPER cC $(zipfile) @Argv}
  var folder = $[mktemp -d $(TEST_TMPDIR)/output.XXXXXXXX]
  shell {cd $folder && $UNZIP -q $(zipfile) || true}  # ignore CRC32 errors
  diff -r $(dir) $folder &> $TEST_log \
      || fail "Unzip after zipper output differ"
}

#### Tests

proc test_zipper {
  mkdir -p $(TEST_TMPDIR)/test/path/to/some
  mkdir -p $(TEST_TMPDIR)/test/some/other/path
  touch $(TEST_TMPDIR)/test/path/to/some/empty_file
  echo "toto" > $(TEST_TMPDIR)/test/path/to/some/file
  echo "titi" > $(TEST_TMPDIR)/test/path/to/some/other_file
  chmod +x $(TEST_TMPDIR)/test/path/to/some/other_file
  echo "tata" > $(TEST_TMPDIR)/test/file
  global filelist := $[cd $(TEST_TMPDIR)/test && find . | sed 's|^./||' | grep -v '^.$]

  assert_zipper_same_after_unzip $(TEST_TMPDIR)/test $(filelist)
  assert_unzip_same_as_zipper $(TEST_TMPDIR)/output.zip

  # Test @filelist format
  echo $(filelist) >$(TEST_TMPDIR)/test.content
  assert_zipper_same_after_unzip $(TEST_TMPDIR)/test @$(TEST_TMPDIR)/test.content
  assert_unzip_same_as_zipper $(TEST_TMPDIR)/output.zip

  # Test flatten option
  shell {cd $(TEST_TMPDIR)/test && $ZIPPER cf $(TEST_TMPDIR)/output.zip $(filelist)}
  $ZIPPER v $(TEST_TMPDIR)/output.zip >$TEST_log
  expect_log "file"
  expect_log "other_file"
  expect_not_log "path"
  expect_not_log "/"

  # Test adding leading garbage at the begining of the file (for
  # self-extractable binary).
  echo "abcdefghi" >$(TEST_TMPDIR)/test.zip
  cat $(TEST_TMPDIR)/output.zip >>$(TEST_TMPDIR)/test.zip
  $ZIPPER v $(TEST_TMPDIR)/test.zip >$TEST_log
  expect_log "file"
  expect_log "other_file"
  expect_not_log "path"
}

proc test_zipper_unzip_selective_files {
  mkdir -p $(TEST_TMPDIR)/test/path/to/some
  mkdir -p $(TEST_TMPDIR)/test/some/other/path
  touch $(TEST_TMPDIR)/test/path/to/some/empty_file
  echo "toto" > $(TEST_TMPDIR)/test/path/to/some/file
  echo "titi" > $(TEST_TMPDIR)/test/path/to/some/other_file
  chmod +x $(TEST_TMPDIR)/test/path/to/some/other_file
  echo "tata" > $(TEST_TMPDIR)/test/file
  global filelist := $[cd $(TEST_TMPDIR)/test && find . | sed 's|^./||' | grep -v '^.$]

  assert_zipper_same_after_unzip $(TEST_TMPDIR)/test $(filelist)
  assert_unzip_same_as_zipper $(TEST_TMPDIR)/output.zip \
      path/to/some/empty_file path/to/some/other_file
}

proc test_zipper_unzip_to_optional_dir {
  mkdir -p $(TEST_TMPDIR)/test/path/to/some
  mkdir -p $(TEST_TMPDIR)/test/some/other/path
  touch $(TEST_TMPDIR)/test/path/to/some/empty_file
  echo "toto" > $(TEST_TMPDIR)/test/path/to/some/file
  echo "titi" > $(TEST_TMPDIR)/test/path/to/some/other_file
  chmod +x $(TEST_TMPDIR)/test/path/to/some/other_file
  echo "tata" > $(TEST_TMPDIR)/test/file
  global filelist := $[cd $(TEST_TMPDIR)/test && find . | sed 's|^./||' | grep -v '^.$]

  assert_zipper_same_after_unzip $(TEST_TMPDIR)/test $(filelist)
  assert_unzip_same_as_zipper $(TEST_TMPDIR)/output.zip -d output_dir2 \
      path/to/some/empty_file path/to/some/other_file
}

proc test_zipper_compression {
  echo -n > $(TEST_TMPDIR)/a
  for i in [$[seq 1 1000]] {
    echo -n "a" >> $(TEST_TMPDIR)/a
  }
  $ZIPPER cCf $(TEST_TMPDIR)/output.zip $(TEST_TMPDIR)/a
  var out_size = $[cat $(TEST_TMPDIR)/output.zip | wc -c | xargs]
  var in_size = $[cat $(TEST_TMPDIR)/a | wc -c | xargs]
  check_gt $(in_size) $(out_size) "Output size is greater than input size"

  rm -fr $(TEST_TMPDIR)/out
  mkdir -p $(TEST_TMPDIR)/out
  shell {cd $(TEST_TMPDIR)/out && $ZIPPER x $(TEST_TMPDIR)/output.zip}
  diff $(TEST_TMPDIR)/a $(TEST_TMPDIR)/out/a &> $TEST_log \
      || fail "Unzip using zipper after zipper output differ"

  rm -fr $(TEST_TMPDIR)/out
  mkdir -p $(TEST_TMPDIR)/out
  shell {cd $(TEST_TMPDIR)/out && $UNZIP -q $(TEST_TMPDIR)/output.zip}
  diff $(TEST_TMPDIR)/a $(TEST_TMPDIR)/out/a &> $TEST_log \
      || fail "Unzip after zipper output differ"
}

proc test_zipper_specify_path {
  mkdir -p $(TEST_TMPDIR)/files
  echo "toto" > $(TEST_TMPDIR)/files/a.txt
  echo "titi" > $(TEST_TMPDIR)/files/b.txt
  rm -fr $(TEST_TMPDIR)/expect/foo/bar
  mkdir -p $(TEST_TMPDIR)/expect/foo/bar
  touch $(TEST_TMPDIR)/expect/empty.txt
  echo "toto" > $(TEST_TMPDIR)/expect/foo/a.txt
  echo "titi" > $(TEST_TMPDIR)/expect/foo/bar/b.txt
  rm -fr $(TEST_TMPDIR)/out
  mkdir -p $(TEST_TMPDIR)/out

  $(ZIPPER) cC $(TEST_TMPDIR)/output.zip empty.txt= \
      foo/a.txt=$(TEST_TMPDIR)/files/a.txt \
      foo/bar/b.txt=$(TEST_TMPDIR)/files/b.txt
  shell {cd $(TEST_TMPDIR)/out && $UNZIP -q $(TEST_TMPDIR)/output.zip}
  diff -r $(TEST_TMPDIR)/expect $(TEST_TMPDIR)/out &> $TEST_log \
      || fail "Unzip after zipper output is not expected"
}

run_suite "zipper tests"
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:DIR)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (AndOr
                        children: [
                          (C {(cd)} 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(dirname)} 
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name BASH_SOURCE>
                                                bracket_op: 
                                                  (ArrayIndex
                                                    expr: (ArithWord w:{(Lit_Digits 0)})
                                                  )
                                                spids: [54 59]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [50 61]
                                )
                              )
                            }
                          )
                          (C {(pwd)})
                        ]
                        op_id: Op_DAmp
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [46 67]
              )
            }
          spids: [45]
        )
      ]
      spids: [45]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:ZIPPER)
          op: Equal
          rhs: {(${ VSub_Name PWD) (/) ($ VSub_Number "$1")}
          spids: [73]
        )
      ]
      spids: [73]
    )
    (C {(shift)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:UNZIP) op:Equal rhs:{($ VSub_Number "$1")} spids:[82])]
      spids: [82]
    )
    (C {(shift)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:ZIP) op:Equal rhs:{($ VSub_Number "$1")} spids:[87])]
      spids: [87]
    )
    (C {(shift)})
    (AndOr
      children: [
        (C {(source)} {(${ VSub_Name DIR) (/testenv.sh)})
        (BraceGroup
          children: [
            (Sentence
              child: 
                (SimpleCommand
                  words: [{(echo)} {(DQ ("testenv.sh not found!"))}]
                  redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[113])]
                )
              terminator: <Op_Semi ";">
            )
            (Sentence child:(C {(exit)} {(1)}) terminator:<Op_Semi ";">)
          ]
          spids: [105]
        )
      ]
      op_id: Op_DPipe
    )
    (FuncDef
      name: assert_unzip_same_as_zipper
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:folder1)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(mktemp)} {(-d)} {(${ VSub_Name TEST_TMPDIR) (/output.XXXXXXXX)})
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [140 149]
                      )
                    }
                  spids: [139]
                )
              ]
              spids: [137]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:folder2)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(mktemp)} {(-d)} {(${ VSub_Name TEST_TMPDIR) (/output.XXXXXXXX)})
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [155 164]
                      )
                    }
                  spids: [154]
                )
              ]
              spids: [152]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:zipfile)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [169]
                )
              ]
              spids: [167]
            )
            (C {(shift)})
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {($ VSub_Name "$folder1")})
                    (AndOr
                      children: [
                        (C {($ VSub_Name "$UNZIP")} {(-q)} {($ VSub_Name "$zipfile")} {($ VSub_At "$@")})
                        (C {(true)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              spids: [176 194]
            )
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {($ VSub_Name "$folder2")})
                    (C {($ VSub_Name "$ZIPPER")} {(x)} {($ VSub_Name "$zipfile")} {($ VSub_At "$@")})
                  ]
                  op_id: Op_DAmp
                )
              spids: [200 214]
            )
            (Sentence
              child: (C {(diff)} {(-r)} {($ VSub_Name "$folder1")} {($ VSub_Name "$folder2")})
              terminator: <Op_Amp "&">
            )
            (AndOr
              children: [
                (SimpleCommand
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {($ VSub_Name "$TEST_log")}
                      spids: [226]
                    )
                  ]
                )
                (C {(fail)} {(DQ ("Unzip and Zipper resulted in different output"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [134]
        )
      spids: [128 133]
    )
    (FuncDef
      name: assert_zipper_same_after_unzip
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [254]
                )
              ]
              spids: [252]
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:zipfile)
                  op: Equal
                  rhs: {(${ VSub_Name TEST_TMPDIR) (/output.zip)}
                  spids: [265]
                )
              ]
              spids: [263]
            )
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {(DQ (${ VSub_Name dir))})
                    (C {($ VSub_Name "$ZIPPER")} {(c)} {(${ VSub_Name zipfile)} {(DQ ($ VSub_At "$@"))})
                  ]
                  op_id: Op_DAmp
                )
              spids: [272 294]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:folder)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(mktemp)} {(-d)} {(${ VSub_Name TEST_TMPDIR) (/output.XXXXXXXX)})
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [300 309]
                      )
                    }
                  spids: [299]
                )
              ]
              spids: [297]
            )
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {($ VSub_Name "$folder")})
                    (AndOr
                      children: [
                        (C {($ VSub_Name "$UNZIP")} {(-q)} {(${ VSub_Name zipfile)})
                        (C {(true)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              spids: [312 330]
            )
            (Sentence
              child: (C {(diff)} {(-r)} {(DQ (${ VSub_Name dir))} {($ VSub_Name "$folder")})
              terminator: <Op_Amp "&">
            )
            (AndOr
              children: [
                (SimpleCommand
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {($ VSub_Name "$TEST_log")}
                      spids: [349]
                    )
                  ]
                )
                (C {(fail)} {(DQ ("Unzip after zipper output differ"))})
              ]
              op_id: Op_DPipe
            )
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {(DQ (${ VSub_Name dir))})
                    (C {($ VSub_Name "$ZIPPER")} {(cC)} {(${ VSub_Name zipfile)} {(DQ ($ VSub_At "$@"))})
                  ]
                  op_id: Op_DAmp
                )
              spids: [368 390]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:folder)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(mktemp)} {(-d)} {(${ VSub_Name TEST_TMPDIR) (/output.XXXXXXXX)})
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [396 405]
                      )
                    }
                  spids: [395]
                )
              ]
              spids: [393]
            )
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {($ VSub_Name "$folder")})
                    (AndOr
                      children: [
                        (C {($ VSub_Name "$UNZIP")} {(-q)} {(${ VSub_Name zipfile)})
                        (C {(true)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              spids: [408 426]
            )
            (Sentence
              child: (C {(diff)} {(-r)} {(DQ (${ VSub_Name dir))} {($ VSub_Name "$folder")})
              terminator: <Op_Amp "&">
            )
            (AndOr
              children: [
                (SimpleCommand
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {($ VSub_Name "$TEST_log")}
                      spids: [445]
                    )
                  ]
                )
                (C {(fail)} {(DQ ("Unzip after zipper output differ"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [249]
        )
      spids: [243 248]
    )
    (FuncDef
      name: test_zipper
      body: 
        (BraceGroup
          children: [
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/test/some/other/path)})
            (C {(touch)} {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/empty_file)})
            (SimpleCommand
              words: [{(echo)} {(DQ (toto))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/file)}
                  spids: [509]
                )
              ]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (titi))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/other_file)}
                  spids: [523]
                )
              ]
            )
            (C {(chmod)} {(Lit_Other "+") (x)} 
              {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/other_file)}
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (tata))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/file)}
                  spids: [548]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filelist)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (AndOr
                                  children: [
                                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/test)})
                                    (Pipeline
                                      children: [
                                        (C {(find)} {(.)})
                                        (C {(sed)} {(SQ <"s|^./||">)})
                                        (C {(grep)} {(-v)} {(SQ <"^.$">)})
                                      ]
                                      negated: False
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [558 589]
                        )
                      )
                    }
                  spids: [556]
                )
              ]
              spids: [556]
            )
            (C {(assert_zipper_same_after_unzip)} {(${ VSub_Name TEST_TMPDIR) (/test)} 
              {(${ VSub_Name filelist)}
            )
            (C {(assert_unzip_same_as_zipper)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)})
            (SimpleCommand
              words: [{(echo)} {(DQ (${ VSub_Name filelist))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test.content)}
                  spids: [627]
                )
              ]
            )
            (C {(assert_zipper_same_after_unzip)} {(${ VSub_Name TEST_TMPDIR) (/test)} 
              {(Lit_Other "@") (${ VSub_Name TEST_TMPDIR) (/test.content)}
            )
            (C {(assert_unzip_same_as_zipper)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)})
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/test)})
                    (C {($ VSub_Name "$ZIPPER")} {(cf)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)} 
                      {(${ VSub_Name filelist)}
                    )
                  ]
                  op_id: Op_DAmp
                )
              spids: [661 683]
            )
            (SimpleCommand
              words: [{($ VSub_Name "$ZIPPER")} {(v)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {($ VSub_Name "$TEST_log")}
                  spids: [695]
                )
              ]
            )
            (C {(expect_log)} {(DQ (file))})
            (C {(expect_log)} {(DQ (other_file))})
            (C {(expect_not_log)} {(DQ (path))})
            (C {(expect_not_log)} {(DQ (/))})
            (SimpleCommand
              words: [{(echo)} {(DQ (abcdefghi))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test.zip)}
                  spids: [742]
                )
              ]
            )
            (SimpleCommand
              words: [{(cat)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test.zip)}
                  spids: [756]
                )
              ]
            )
            (SimpleCommand
              words: [{($ VSub_Name "$ZIPPER")} {(v)} {(${ VSub_Name TEST_TMPDIR) (/test.zip)}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {($ VSub_Name "$TEST_log")}
                  spids: [772]
                )
              ]
            )
            (C {(expect_log)} {(DQ (file))})
            (C {(expect_log)} {(DQ (other_file))})
            (C {(expect_not_log)} {(DQ (path))})
          ]
          spids: [472]
        )
      spids: [466 471]
    )
    (FuncDef
      name: test_zipper_unzip_selective_files
      body: 
        (BraceGroup
          children: [
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/test/some/other/path)})
            (C {(touch)} {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/empty_file)})
            (SimpleCommand
              words: [{(echo)} {(DQ (toto))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/file)}
                  spids: [842]
                )
              ]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (titi))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/other_file)}
                  spids: [856]
                )
              ]
            )
            (C {(chmod)} {(Lit_Other "+") (x)} 
              {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/other_file)}
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (tata))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/file)}
                  spids: [881]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filelist)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (AndOr
                                  children: [
                                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/test)})
                                    (Pipeline
                                      children: [
                                        (C {(find)} {(.)})
                                        (C {(sed)} {(SQ <"s|^./||">)})
                                        (C {(grep)} {(-v)} {(SQ <"^.$">)})
                                      ]
                                      negated: False
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [891 922]
                        )
                      )
                    }
                  spids: [889]
                )
              ]
              spids: [889]
            )
            (C {(assert_zipper_same_after_unzip)} {(${ VSub_Name TEST_TMPDIR) (/test)} 
              {(${ VSub_Name filelist)}
            )
            (C {(assert_unzip_same_as_zipper)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)} 
              {(path/to/some/empty_file)} {(path/to/some/other_file)}
            )
          ]
          spids: [805]
        )
      spids: [799 804]
    )
    (FuncDef
      name: test_zipper_unzip_to_optional_dir
      body: 
        (BraceGroup
          children: [
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/test/some/other/path)})
            (C {(touch)} {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/empty_file)})
            (SimpleCommand
              words: [{(echo)} {(DQ (toto))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/file)}
                  spids: [998]
                )
              ]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (titi))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/other_file)}
                  spids: [1012]
                )
              ]
            )
            (C {(chmod)} {(Lit_Other "+") (x)} 
              {(${ VSub_Name TEST_TMPDIR) (/test/path/to/some/other_file)}
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (tata))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/test/file)}
                  spids: [1037]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:filelist)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (AndOr
                                  children: [
                                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/test)})
                                    (Pipeline
                                      children: [
                                        (C {(find)} {(.)})
                                        (C {(sed)} {(SQ <"s|^./||">)})
                                        (C {(grep)} {(-v)} {(SQ <"^.$">)})
                                      ]
                                      negated: False
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [1047 1078]
                        )
                      )
                    }
                  spids: [1045]
                )
              ]
              spids: [1045]
            )
            (C {(assert_zipper_same_after_unzip)} {(${ VSub_Name TEST_TMPDIR) (/test)} 
              {(${ VSub_Name filelist)}
            )
            (C {(assert_unzip_same_as_zipper)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)} {(-d)} 
              {(output_dir2)} {(path/to/some/empty_file)} {(path/to/some/other_file)}
            )
          ]
          spids: [961]
        )
      spids: [955 960]
    )
    (FuncDef
      name: test_zipper_compression
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(-n)}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/a)}
                  spids: [1128]
                )
              ]
            )
            (ForEach
              iter_name: i
              iter_words: [
                {
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(seq)} {(1)} {(1000)})])
                    left_token: <Left_CommandSub "$(">
                    spids: [1142 1148]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (SimpleCommand
                      words: [{(echo)} {(-n)} {(DQ (a))}]
                      redirects: [
                        (Redir
                          op_id: Redir_DGreat
                          fd: -1
                          arg_word: {(${ VSub_Name TEST_TMPDIR) (/a)}
                          spids: [1162]
                        )
                      ]
                    )
                  ]
                  spids: [1151 1170]
                )
              spids: [1141 1149]
            )
            (C {($ VSub_Name "$ZIPPER")} {(cCf)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)} 
              {(${ VSub_Name TEST_TMPDIR) (/a)}
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:out_size)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(cat)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)})
                                  (C {(wc)} {(-c)})
                                  (C {(xargs)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1191 1208]
                      )
                    }
                  spids: [1190]
                )
              ]
              spids: [1188]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:in_size)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(cat)} {(${ VSub_Name TEST_TMPDIR) (/a)})
                                  (C {(wc)} {(-c)})
                                  (C {(xargs)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1214 1231]
                      )
                    }
                  spids: [1213]
                )
              ]
              spids: [1211]
            )
            (C {(check_gt)} {(DQ (${ VSub_Name in_size))} {(DQ (${ VSub_Name out_size))} 
              {(DQ ("Output size is greater than input size"))}
            )
            (C {(rm)} {(-fr)} {(${ VSub_Name TEST_TMPDIR) (/out)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/out)})
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/out)})
                    (C {($ VSub_Name "$ZIPPER")} {(x)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)})
                  ]
                  op_id: Op_DAmp
                )
              spids: [1274 1292]
            )
            (Sentence
              child: 
                (C {(diff)} {(${ VSub_Name TEST_TMPDIR) (/a)} {(${ VSub_Name TEST_TMPDIR) (/out/a)})
              terminator: <Op_Amp "&">
            )
            (AndOr
              children: [
                (SimpleCommand
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {($ VSub_Name "$TEST_log")}
                      spids: [1308]
                    )
                  ]
                )
                (C {(fail)} {(DQ ("Unzip using zipper after zipper output differ"))})
              ]
              op_id: Op_DPipe
            )
            (C {(rm)} {(-fr)} {(${ VSub_Name TEST_TMPDIR) (/out)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/out)})
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/out)})
                    (C {($ VSub_Name "$UNZIP")} {(-q)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)})
                  ]
                  op_id: Op_DAmp
                )
              spids: [1344 1362]
            )
            (Sentence
              child: 
                (C {(diff)} {(${ VSub_Name TEST_TMPDIR) (/a)} {(${ VSub_Name TEST_TMPDIR) (/out/a)})
              terminator: <Op_Amp "&">
            )
            (AndOr
              children: [
                (SimpleCommand
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {($ VSub_Name "$TEST_log")}
                      spids: [1378]
                    )
                  ]
                )
                (C {(fail)} {(DQ ("Unzip after zipper output differ"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [1121]
        )
      spids: [1115 1120]
    )
    (FuncDef
      name: test_zipper_specify_path
      body: 
        (BraceGroup
          children: [
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/files)})
            (SimpleCommand
              words: [{(echo)} {(DQ (toto))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/files/a.txt)}
                  spids: [1420]
                )
              ]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (titi))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/files/b.txt)}
                  spids: [1434]
                )
              ]
            )
            (C {(rm)} {(-fr)} {(${ VSub_Name TEST_TMPDIR) (/expect/foo/bar)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/expect/foo/bar)})
            (C {(touch)} {(${ VSub_Name TEST_TMPDIR) (/expect/empty.txt)})
            (SimpleCommand
              words: [{(echo)} {(DQ (toto))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/expect/foo/a.txt)}
                  spids: [1476]
                )
              ]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ (titi))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(${ VSub_Name TEST_TMPDIR) (/expect/foo/bar/b.txt)}
                  spids: [1490]
                )
              ]
            )
            (C {(rm)} {(-fr)} {(${ VSub_Name TEST_TMPDIR) (/out)})
            (C {(mkdir)} {(-p)} {(${ VSub_Name TEST_TMPDIR) (/out)})
            (C {(${ VSub_Name ZIPPER)} {(cC)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)} 
              {(empty.txt) (Lit_Other "=")} {(foo/a.txt) (Lit_Other "=") (${ VSub_Name TEST_TMPDIR) (/files/a.txt)} 
              {(foo/bar/b.txt) (Lit_Other "=") (${ VSub_Name TEST_TMPDIR) (/files/b.txt)}
            )
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} {(${ VSub_Name TEST_TMPDIR) (/out)})
                    (C {($ VSub_Name "$UNZIP")} {(-q)} {(${ VSub_Name TEST_TMPDIR) (/output.zip)})
                  ]
                  op_id: Op_DAmp
                )
              spids: [1552 1570]
            )
            (Sentence
              child: 
                (C {(diff)} {(-r)} {(${ VSub_Name TEST_TMPDIR) (/expect)} 
                  {(${ VSub_Name TEST_TMPDIR) (/out)}
                )
              terminator: <Op_Amp "&">
            )
            (AndOr
              children: [
                (SimpleCommand
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {($ VSub_Name "$TEST_log")}
                      spids: [1588]
                    )
                  ]
                )
                (C {(fail)} {(DQ ("Unzip after zipper output is not expected"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [1401]
        )
      spids: [1395 1400]
    )
    (C {(run_suite)} {(DQ ("zipper tests"))})
  ]
)