t/t1510-repo-setup.sh

   1 #!/bin/sh
   2
   3 test_description="Tests of cwd/prefix/worktree/gitdir setup in all cases
   4
   5 A few rules for repo setup:
   6
   7 1. GIT_DIR is relative to user's cwd. --git-dir is equivalent to
   8    GIT_DIR.
   9
  10 2. .git file is relative to parent directory. .git file is basically
  11    symlink in disguise. The directory where .git file points to will
  12    become new git_dir.
  13
  14 3. core.worktree is relative to git_dir.
  15
  16 4. GIT_WORK_TREE is relative to user's cwd. --work-tree is
  17    equivalent to GIT_WORK_TREE.
  18
  19 5. GIT_WORK_TREE/core.worktree was originally meant to work only if
  20    GIT_DIR is set, but earlier git didn't enforce it, and some scripts
  21    depend on the implementation that happened to first discover .git by
  22    going up from the users $cwd and then using the specified working tree
  23    that may or may not have any relation to where .git was found in.  This
  24    historical behaviour must be kept.
  25
  26 6. Effective GIT_WORK_TREE overrides core.worktree and core.bare
  27
  28 7. Effective core.worktree conflicts with core.bare
  29
  30 8. If GIT_DIR is set but neither worktree nor bare setting is given,
  31    original cwd becomes worktree.
  32
  33 9. If .git discovery is done inside a repo, the repo becomes a bare
  34    repo. .git discovery is performed if GIT_DIR is not set.
  35
  36 10. If no worktree is available, cwd remains unchanged, prefix is
  37     NULL.
  38
  39 11. When user's cwd is outside worktree, cwd remains unchanged,
  40     prefix is NULL.
  41 "
  42 . ./test-lib.sh
  43
  44 here=$(pwd)
  45
  46 test_repo () {
  47         (
  48                 cd "$1" &&
  49                 if test -n "$2"
  50                 then
  51                         GIT_DIR="$2" &&
  52                         export GIT_DIR
  53                 fi &&
  54                 if test -n "$3"
  55                 then
  56                         GIT_WORK_TREE="$3" &&
  57                         export GIT_WORK_TREE
  58                 fi &&
  59                 rm -f trace &&
  60                 GIT_TRACE_SETUP="$(pwd)/trace" git symbolic-ref HEAD >/dev/null &&
  61                 grep '^setup: ' trace >result &&
  62                 test_cmp expected result
  63         )
  64 }
  65
  66 maybe_config () {
  67         file=$1 var=$2 value=$3 &&
  68         if test "$value" != unset
  69         then
  70                 git config --file="$file" "$var" "$value"
  71         fi
  72 }
  73
  74 setup_repo () {
  75         name=$1 worktreecfg=$2 gitfile=$3 barecfg=$4 &&
  76         sane_unset GIT_DIR GIT_WORK_TREE &&
  77
  78         git init "$name" &&
  79         maybe_config "$name/.git/config" core.worktree "$worktreecfg" &&
  80         maybe_config "$name/.git/config" core.bare "$barecfg" &&
  81         mkdir -p "$name/sub/sub" &&
  82
  83         if test "${gitfile:+set}"
  84         then
  85                 mv "$name/.git" "$name.git" &&
  86                 echo "gitdir: ../$name.git" >"$name/.git"
  87         fi
  88 }
  89
  90 maybe_set () {
  91         var=$1 value=$2 &&
  92         if test "$value" != unset
  93         then
  94                 eval "$var=\$value" &&
  95                 export $var
  96         fi
  97 }
  98
  99 setup_env () {
 100         worktreenv=$1 gitdirenv=$2 &&
 101         sane_unset GIT_DIR GIT_WORK_TREE &&
 102         maybe_set GIT_DIR "$gitdirenv" &&
 103         maybe_set GIT_WORK_TREE "$worktreeenv"
 104 }
 105
 106 expect () {
 107         cat >"$1/expected" <<-EOF
 108         setup: git_dir: $2
 109         setup: worktree: $3
 110         setup: cwd: $4
 111         setup: prefix: $5
 112         EOF
 113 }
 114
 115 try_case () {
 116         name=$1 worktreeenv=$2 gitdirenv=$3 &&
 117         setup_env "$worktreeenv" "$gitdirenv" &&
 118         expect "$name" "$4" "$5" "$6" "$7" &&
 119         test_repo "$name"
 120 }
 121
 122 run_wt_tests () {
 123         N=$1 gitfile=$2
 124
 125         absgit="$here/$N/.git"
 126         dotgit=.git
 127         dotdotgit=../../.git
 128
 129         if test "$gitfile"
 130         then
 131                 absgit="$here/$N.git"
 132                 dotgit=$absgit dotdotgit=$absgit
 133         fi
 134
 135         test_expect_success "#$N: explicit GIT_WORK_TREE and GIT_DIR at toplevel" '
 136                 try_case $N "$here/$N" .git \
 137                         "$dotgit" "$here/$N" "$here/$N" "(null)" &&
 138                 try_case $N . .git \
 139                         "$dotgit" "$here/$N" "$here/$N" "(null)" &&
 140                 try_case $N "$here/$N" "$here/$N/.git" \
 141                         "$absgit" "$here/$N" "$here/$N" "(null)" &&
 142                 try_case $N . "$here/$N/.git" \
 143                         "$absgit" "$here/$N" "$here/$N" "(null)"
 144         '
 145
 146         test_expect_success "#$N: explicit GIT_WORK_TREE and GIT_DIR in subdir" '
 147                 try_case $N/sub/sub "$here/$N" ../../.git \
 148                         "$absgit" "$here/$N" "$here/$N" sub/sub/ &&
 149                 try_case $N/sub/sub ../.. ../../.git \
 150                         "$absgit" "$here/$N" "$here/$N" sub/sub/ &&
 151                 try_case $N/sub/sub "$here/$N" "$here/$N/.git" \
 152                         "$absgit" "$here/$N" "$here/$N" sub/sub/ &&
 153                 try_case $N/sub/sub ../.. "$here/$N/.git" \
 154                         "$absgit" "$here/$N" "$here/$N" sub/sub/
 155         '
 156
 157         test_expect_success "#$N: explicit GIT_WORK_TREE from parent of worktree" '
 158                 try_case $N "$here/$N/wt" .git \
 159                         "$dotgit" "$here/$N/wt" "$here/$N" "(null)" &&
 160                 try_case $N wt .git \
 161                         "$dotgit" "$here/$N/wt" "$here/$N" "(null)" &&
 162                 try_case $N wt "$here/$N/.git" \
 163                         "$absgit" "$here/$N/wt" "$here/$N" "(null)" &&
 164                 try_case $N "$here/$N/wt" "$here/$N/.git" \
 165                         "$absgit" "$here/$N/wt" "$here/$N" "(null)"
 166         '
 167
 168         test_expect_success "#$N: explicit GIT_WORK_TREE from nephew of worktree" '
 169                 try_case $N/sub/sub "$here/$N/wt" ../../.git \
 170                         "$dotdotgit" "$here/$N/wt" "$here/$N/sub/sub" "(null)" &&
 171                 try_case $N/sub/sub ../../wt ../../.git \
 172                         "$dotdotgit" "$here/$N/wt" "$here/$N/sub/sub" "(null)" &&
 173                 try_case $N/sub/sub ../../wt "$here/$N/.git" \
 174                         "$absgit" "$here/$N/wt" "$here/$N/sub/sub" "(null)" &&
 175                 try_case $N/sub/sub "$here/$N/wt" "$here/$N/.git" \
 176                         "$absgit" "$here/$N/wt" "$here/$N/sub/sub" "(null)"
 177         '
 178
 179         test_expect_success "#$N: chdir_to_toplevel uses worktree, not git dir" '
 180                 try_case $N "$here" .git \
 181                         "$absgit" "$here" "$here" $N/ &&
 182                 try_case $N .. .git \
 183                         "$absgit" "$here" "$here" $N/ &&
 184                 try_case $N .. "$here/$N/.git" \
 185                         "$absgit" "$here" "$here" $N/ &&
 186                 try_case $N "$here" "$here/$N/.git" \
 187                         "$absgit" "$here" "$here" $N/
 188         '
 189
 190         test_expect_success "#$N: chdir_to_toplevel uses worktree (from subdir)" '
 191                 try_case $N/sub/sub "$here" ../../.git \
 192                         "$absgit" "$here" "$here" $N/sub/sub/ &&
 193                 try_case $N/sub/sub ../../.. ../../.git \
 194                         "$absgit" "$here" "$here" $N/sub/sub/ &&
 195                 try_case $N/sub/sub ../../../ "$here/$N/.git" \
 196                         "$absgit" "$here" "$here" $N/sub/sub/ &&
 197                 try_case $N/sub/sub "$here" "$here/$N/.git" \
 198                         "$absgit" "$here" "$here" $N/sub/sub/
 199         '
 200 }
 201
 202 # try_repo #c GIT_WORK_TREE GIT_DIR core.worktree .gitfile? core.bare \
 203 #       (git dir) (work tree) (cwd) (prefix) \  <-- at toplevel
 204 #       (git dir) (work tree) (cwd) (prefix)    <-- from subdir
 205 try_repo () {
 206         name=$1 worktreeenv=$2 gitdirenv=$3 &&
 207         setup_repo "$name" "$4" "$5" "$6" &&
 208         shift 6 &&
 209         try_case "$name" "$worktreeenv" "$gitdirenv" \
 210                 "$1" "$2" "$3" "$4" &&
 211         shift 4 &&
 212         case "$gitdirenv" in
 213         /* | ?:/* | unset) ;;
 214         *)
 215                 gitdirenv=../$gitdirenv ;;
 216         esac &&
 217         try_case "$name/sub" "$worktreeenv" "$gitdirenv" \
 218                 "$1" "$2" "$3" "$4"
 219 }
 220
 221 # Bit 0 = GIT_WORK_TREE
 222 # Bit 1 = GIT_DIR
 223 # Bit 2 = core.worktree
 224 # Bit 3 = .git is a file
 225 # Bit 4 = bare repo
 226 # Case# = encoding of the above 5 bits
 227
 228 test_expect_success '#0: nonbare repo, no explicit configuration' '
 229         try_repo 0 unset unset unset "" unset \
 230                 .git "$here/0" "$here/0" "(null)" \
 231                 .git "$here/0" "$here/0" sub/ 2>message &&
 232         ! test -s message
 233 '
 234
 235 test_expect_success '#1: GIT_WORK_TREE without explicit GIT_DIR is accepted' '
 236         mkdir -p wt &&
 237         try_repo 1 "$here" unset unset "" unset \
 238                 "$here/1/.git" "$here" "$here" 1/ \
 239                 "$here/1/.git" "$here" "$here" 1/sub/ 2>message &&
 240         ! test -s message
 241 '
 242
 243 test_expect_success '#2: worktree defaults to cwd with explicit GIT_DIR' '
 244         try_repo 2 unset "$here/2/.git" unset "" unset \
 245                 "$here/2/.git" "$here/2" "$here/2" "(null)" \
 246                 "$here/2/.git" "$here/2/sub" "$here/2/sub" "(null)"
 247 '
 248
 249 test_expect_success '#2b: relative GIT_DIR' '
 250         try_repo 2b unset ".git" unset "" unset \
 251                 ".git" "$here/2b" "$here/2b" "(null)" \
 252                 "../.git" "$here/2b/sub" "$here/2b/sub" "(null)"
 253 '
 254
 255 test_expect_success '#3: setup' '
 256         setup_repo 3 unset "" unset &&
 257         mkdir -p 3/sub/sub 3/wt/sub
 258 '
 259 run_wt_tests 3
 260
 261 test_expect_success '#4: core.worktree without GIT_DIR set is accepted' '
 262         setup_repo 4 ../sub "" unset &&
 263         mkdir -p 4/sub sub &&
 264         try_case 4 unset unset \
 265                 .git "$here/4/sub" "$here/4" "(null)" \
 266                 "$here/4/.git" "$here/4/sub" "$here/4/sub" "(null)" 2>message &&
 267         ! test -s message
 268 '
 269
 270 test_expect_success '#5: core.worktree + GIT_WORK_TREE is accepted' '
 271         # or: you cannot intimidate away the lack of GIT_DIR setting
 272         try_repo 5 "$here" unset "$here/5" "" unset \
 273                 "$here/5/.git" "$here" "$here" 5/ \
 274                 "$here/5/.git" "$here" "$here" 5/sub/ 2>message &&
 275         try_repo 5a .. unset "$here/5a" "" unset \
 276                 "$here/5a/.git" "$here" "$here" 5a/ \
 277                 "$here/5a/.git" "$here/5a" "$here/5a" sub/ &&
 278         ! test -s message
 279 '
 280
 281 test_expect_success '#6: setting GIT_DIR brings core.worktree to life' '
 282         setup_repo 6 "$here/6" "" unset &&
 283         try_case 6 unset .git \
 284                 .git "$here/6" "$here/6" "(null)" &&
 285         try_case 6 unset "$here/6/.git" \
 286                 "$here/6/.git" "$here/6" "$here/6" "(null)" &&
 287         try_case 6/sub/sub unset ../../.git \
 288                 "$here/6/.git" "$here/6" "$here/6" sub/sub/ &&
 289         try_case 6/sub/sub unset "$here/6/.git" \
 290                 "$here/6/.git" "$here/6" "$here/6" sub/sub/
 291 '
 292
 293 test_expect_success '#6b: GIT_DIR set, core.worktree relative' '
 294         setup_repo 6b .. "" unset &&
 295         try_case 6b unset .git \
 296                 .git "$here/6b" "$here/6b" "(null)" &&
 297         try_case 6b unset "$here/6b/.git" \
 298                 "$here/6b/.git" "$here/6b" "$here/6b" "(null)" &&
 299         try_case 6b/sub/sub unset ../../.git \
 300                 "$here/6b/.git" "$here/6b" "$here/6b" sub/sub/ &&
 301         try_case 6b/sub/sub unset "$here/6b/.git" \
 302                 "$here/6b/.git" "$here/6b" "$here/6b" sub/sub/
 303 '
 304
 305 test_expect_success '#6c: GIT_DIR set, core.worktree=../wt (absolute)' '
 306         setup_repo 6c "$here/6c/wt" "" unset &&
 307         mkdir -p 6c/wt/sub &&
 308
 309         try_case 6c unset .git \
 310                 .git "$here/6c/wt" "$here/6c" "(null)" &&
 311         try_case 6c unset "$here/6c/.git" \
 312                 "$here/6c/.git" "$here/6c/wt" "$here/6c" "(null)" &&
 313         try_case 6c/sub/sub unset ../../.git \
 314                 ../../.git "$here/6c/wt" "$here/6c/sub/sub" "(null)" &&
 315         try_case 6c/sub/sub unset "$here/6c/.git" \
 316                 "$here/6c/.git" "$here/6c/wt" "$here/6c/sub/sub" "(null)"
 317 '
 318
 319 test_expect_success '#6d: GIT_DIR set, core.worktree=../wt (relative)' '
 320         setup_repo 6d "$here/6d/wt" "" unset &&
 321         mkdir -p 6d/wt/sub &&
 322
 323         try_case 6d unset .git \
 324                 .git "$here/6d/wt" "$here/6d" "(null)" &&
 325         try_case 6d unset "$here/6d/.git" \
 326                 "$here/6d/.git" "$here/6d/wt" "$here/6d" "(null)" &&
 327         try_case 6d/sub/sub unset ../../.git \
 328                 ../../.git "$here/6d/wt" "$here/6d/sub/sub" "(null)" &&
 329         try_case 6d/sub/sub unset "$here/6d/.git" \
 330                 "$here/6d/.git" "$here/6d/wt" "$here/6d/sub/sub" "(null)"
 331 '
 332
 333 test_expect_success '#6e: GIT_DIR set, core.worktree=../.. (absolute)' '
 334         setup_repo 6e "$here" "" unset &&
 335         try_case 6e unset .git \
 336                 "$here/6e/.git" "$here" "$here" 6e/ &&
 337         try_case 6e unset "$here/6e/.git" \
 338                 "$here/6e/.git" "$here" "$here" 6e/ &&
 339         try_case 6e/sub/sub unset ../../.git \
 340                 "$here/6e/.git" "$here" "$here" 6e/sub/sub/ &&
 341         try_case 6e/sub/sub unset "$here/6e/.git" \
 342                 "$here/6e/.git" "$here" "$here" 6e/sub/sub/
 343 '
 344
 345 test_expect_success '#6f: GIT_DIR set, core.worktree=../.. (relative)' '
 346         setup_repo 6f ../../ "" unset &&
 347         try_case 6f unset .git \
 348                 "$here/6f/.git" "$here" "$here" 6f/ &&
 349         try_case 6f unset "$here/6f/.git" \
 350                 "$here/6f/.git" "$here" "$here" 6f/ &&
 351         try_case 6f/sub/sub unset ../../.git \
 352                 "$here/6f/.git" "$here" "$here" 6f/sub/sub/ &&
 353         try_case 6f/sub/sub unset "$here/6f/.git" \
 354                 "$here/6f/.git" "$here" "$here" 6f/sub/sub/
 355 '
 356
 357 # case #7: GIT_WORK_TREE overrides core.worktree.
 358 test_expect_success '#7: setup' '
 359         setup_repo 7 non-existent "" unset &&
 360         mkdir -p 7/sub/sub 7/wt/sub
 361 '
 362 run_wt_tests 7
 363
 364 test_expect_success '#8: gitfile, easy case' '
 365         try_repo 8 unset unset unset gitfile unset \
 366                 "$here/8.git" "$here/8" "$here/8" "(null)" \
 367                 "$here/8.git" "$here/8" "$here/8" sub/
 368 '
 369
 370 test_expect_success '#9: GIT_WORK_TREE accepted with gitfile' '
 371         mkdir -p 9/wt &&
 372         try_repo 9 wt unset unset gitfile unset \
 373                 "$here/9.git" "$here/9/wt" "$here/9" "(null)" \
 374                 "$here/9.git" "$here/9/sub/wt" "$here/9/sub" "(null)" 2>message &&
 375         ! test -s message
 376 '
 377
 378 test_expect_success '#10: GIT_DIR can point to gitfile' '
 379         try_repo 10 unset "$here/10/.git" unset gitfile unset \
 380                 "$here/10.git" "$here/10" "$here/10" "(null)" \
 381                 "$here/10.git" "$here/10/sub" "$here/10/sub" "(null)"
 382 '
 383
 384 test_expect_success '#10b: relative GIT_DIR can point to gitfile' '
 385         try_repo 10b unset .git unset gitfile unset \
 386                 "$here/10b.git" "$here/10b" "$here/10b" "(null)" \
 387                 "$here/10b.git" "$here/10b/sub" "$here/10b/sub" "(null)"
 388 '
 389
 390 # case #11: GIT_WORK_TREE works, gitfile case.
 391 test_expect_success '#11: setup' '
 392         setup_repo 11 unset gitfile unset &&
 393         mkdir -p 11/sub/sub 11/wt/sub
 394 '
 395 run_wt_tests 11 gitfile
 396
 397 test_expect_success '#12: core.worktree with gitfile is accepted' '
 398         try_repo 12 unset unset "$here/12" gitfile unset \
 399                 "$here/12.git" "$here/12" "$here/12" "(null)" \
 400                 "$here/12.git" "$here/12" "$here/12" sub/ 2>message &&
 401         ! test -s message
 402 '
 403
 404 test_expect_success '#13: core.worktree+GIT_WORK_TREE accepted (with gitfile)' '
 405         # or: you cannot intimidate away the lack of GIT_DIR setting
 406         try_repo 13 non-existent-too unset non-existent gitfile unset \
 407                 "$here/13.git" "$here/13/non-existent-too" "$here/13" "(null)" \
 408                 "$here/13.git" "$here/13/sub/non-existent-too" "$here/13/sub" "(null)" 2>message &&
 409         ! test -s message
 410 '
 411
 412 # case #14.
 413 # If this were more table-driven, it could share code with case #6.
 414
 415 test_expect_success '#14: core.worktree with GIT_DIR pointing to gitfile' '
 416         setup_repo 14 "$here/14" gitfile unset &&
 417         try_case 14 unset .git \
 418                 "$here/14.git" "$here/14" "$here/14" "(null)" &&
 419         try_case 14 unset "$here/14/.git" \
 420                 "$here/14.git" "$here/14" "$here/14" "(null)" &&
 421         try_case 14/sub/sub unset ../../.git \
 422                 "$here/14.git" "$here/14" "$here/14" sub/sub/ &&
 423         try_case 14/sub/sub unset "$here/14/.git" \
 424                 "$here/14.git" "$here/14" "$here/14" sub/sub/ &&
 425
 426         setup_repo 14c "$here/14c/wt" gitfile unset &&
 427         mkdir -p 14c/wt/sub &&
 428
 429         try_case 14c unset .git \
 430                 "$here/14c.git" "$here/14c/wt" "$here/14c" "(null)" &&
 431         try_case 14c unset "$here/14c/.git" \
 432                 "$here/14c.git" "$here/14c/wt" "$here/14c" "(null)" &&
 433         try_case 14c/sub/sub unset ../../.git \
 434                 "$here/14c.git" "$here/14c/wt" "$here/14c/sub/sub" "(null)" &&
 435         try_case 14c/sub/sub unset "$here/14c/.git" \
 436                 "$here/14c.git" "$here/14c/wt" "$here/14c/sub/sub" "(null)" &&
 437
 438         setup_repo 14d "$here/14d/wt" gitfile unset &&
 439         mkdir -p 14d/wt/sub &&
 440
 441         try_case 14d unset .git \
 442                 "$here/14d.git" "$here/14d/wt" "$here/14d" "(null)" &&
 443         try_case 14d unset "$here/14d/.git" \
 444                 "$here/14d.git" "$here/14d/wt" "$here/14d" "(null)" &&
 445         try_case 14d/sub/sub unset ../../.git \
 446                 "$here/14d.git" "$here/14d/wt" "$here/14d/sub/sub" "(null)" &&
 447         try_case 14d/sub/sub unset "$here/14d/.git" \
 448                 "$here/14d.git" "$here/14d/wt" "$here/14d/sub/sub" "(null)" &&
 449
 450         setup_repo 14e "$here" gitfile unset &&
 451         try_case 14e unset .git \
 452                 "$here/14e.git" "$here" "$here" 14e/ &&
 453         try_case 14e unset "$here/14e/.git" \
 454                 "$here/14e.git" "$here" "$here" 14e/ &&
 455         try_case 14e/sub/sub unset ../../.git \
 456                 "$here/14e.git" "$here" "$here" 14e/sub/sub/ &&
 457         try_case 14e/sub/sub unset "$here/14e/.git" \
 458                 "$here/14e.git" "$here" "$here" 14e/sub/sub/
 459 '
 460
 461 test_expect_success '#14b: core.worktree is relative to actual git dir' '
 462         setup_repo 14b ../14b gitfile unset &&
 463         try_case 14b unset .git \
 464                 "$here/14b.git" "$here/14b" "$here/14b" "(null)" &&
 465         try_case 14b unset "$here/14b/.git" \
 466                 "$here/14b.git" "$here/14b" "$here/14b" "(null)" &&
 467         try_case 14b/sub/sub unset ../../.git \
 468                 "$here/14b.git" "$here/14b" "$here/14b" sub/sub/ &&
 469         try_case 14b/sub/sub unset "$here/14b/.git" \
 470                 "$here/14b.git" "$here/14b" "$here/14b" sub/sub/ &&
 471
 472         setup_repo 14f ../ gitfile unset &&
 473         try_case 14f unset .git \
 474                 "$here/14f.git" "$here" "$here" 14f/ &&
 475         try_case 14f unset "$here/14f/.git" \
 476                 "$here/14f.git" "$here" "$here" 14f/ &&
 477         try_case 14f/sub/sub unset ../../.git \
 478                 "$here/14f.git" "$here" "$here" 14f/sub/sub/ &&
 479         try_case 14f/sub/sub unset "$here/14f/.git" \
 480                 "$here/14f.git" "$here" "$here" 14f/sub/sub/
 481 '
 482
 483 # case #15: GIT_WORK_TREE overrides core.worktree (gitfile case).
 484 test_expect_success '#15: setup' '
 485         setup_repo 15 non-existent gitfile unset &&
 486         mkdir -p 15/sub/sub 15/wt/sub
 487 '
 488 run_wt_tests 15 gitfile
 489
 490 test_expect_success '#16a: implicitly bare repo (cwd inside .git dir)' '
 491         setup_repo 16a unset "" unset &&
 492         mkdir -p 16a/.git/wt/sub &&
 493
 494         try_case 16a/.git unset unset \
 495                 . "(null)" "$here/16a/.git" "(null)" &&
 496         try_case 16a/.git/wt unset unset \
 497                 "$here/16a/.git" "(null)" "$here/16a/.git/wt" "(null)" &&
 498         try_case 16a/.git/wt/sub unset unset \
 499                 "$here/16a/.git" "(null)" "$here/16a/.git/wt/sub" "(null)"
 500 '
 501
 502 test_expect_success '#16b: bare .git (cwd inside .git dir)' '
 503         setup_repo 16b unset "" true &&
 504         mkdir -p 16b/.git/wt/sub &&
 505
 506         try_case 16b/.git unset unset \
 507                 . "(null)" "$here/16b/.git" "(null)" &&
 508         try_case 16b/.git/wt unset unset \
 509                 "$here/16b/.git" "(null)" "$here/16b/.git/wt" "(null)" &&
 510         try_case 16b/.git/wt/sub unset unset \
 511                 "$here/16b/.git" "(null)" "$here/16b/.git/wt/sub" "(null)"
 512 '
 513
 514 test_expect_success '#16c: bare .git has no worktree' '
 515         try_repo 16c unset unset unset "" true \
 516                 .git "(null)" "$here/16c" "(null)" \
 517                 "$here/16c/.git" "(null)" "$here/16c/sub" "(null)"
 518 '
 519
 520 test_expect_success '#16d: bareness preserved across alias' '
 521         setup_repo 16d unset "" unset &&
 522         (
 523                 cd 16d/.git &&
 524                 test_must_fail git status &&
 525                 git config alias.st status &&
 526                 test_must_fail git st
 527         )
 528 '
 529
 530 test_expect_success '#16e: bareness preserved by --bare' '
 531         setup_repo 16e unset "" unset &&
 532         (
 533                 cd 16e/.git &&
 534                 test_must_fail git status &&
 535                 test_must_fail git --bare status
 536         )
 537 '
 538
 539 test_expect_success '#17: GIT_WORK_TREE without explicit GIT_DIR is accepted (bare case)' '
 540         # Just like #16.
 541         setup_repo 17a unset "" true &&
 542         setup_repo 17b unset "" true &&
 543         mkdir -p 17a/.git/wt/sub &&
 544         mkdir -p 17b/.git/wt/sub &&
 545
 546         try_case 17a/.git "$here/17a" unset \
 547                 "$here/17a/.git" "$here/17a" "$here/17a" .git/ \
 548                 2>message &&
 549         try_case 17a/.git/wt "$here/17a" unset \
 550                 "$here/17a/.git" "$here/17a" "$here/17a" .git/wt/ &&
 551         try_case 17a/.git/wt/sub "$here/17a" unset \
 552                 "$here/17a/.git" "$here/17a" "$here/17a" .git/wt/sub/ &&
 553
 554         try_case 17b/.git "$here/17b" unset \
 555                 "$here/17b/.git" "$here/17b" "$here/17b" .git/ &&
 556         try_case 17b/.git/wt "$here/17b" unset \
 557                 "$here/17b/.git" "$here/17b" "$here/17b" .git/wt/ &&
 558         try_case 17b/.git/wt/sub "$here/17b" unset \
 559                 "$here/17b/.git" "$here/17b" "$here/17b" .git/wt/sub/ &&
 560
 561         try_repo 17c "$here/17c" unset unset "" true \
 562                 .git "$here/17c" "$here/17c" "(null)" \
 563                 "$here/17c/.git" "$here/17c" "$here/17c" sub/ 2>message &&
 564         ! test -s message
 565 '
 566
 567 test_expect_success '#18: bare .git named by GIT_DIR has no worktree' '
 568         try_repo 18 unset .git unset "" true \
 569                 .git "(null)" "$here/18" "(null)" \
 570                 ../.git "(null)" "$here/18/sub" "(null)" &&
 571         try_repo 18b unset "$here/18b/.git" unset "" true \
 572                 "$here/18b/.git" "(null)" "$here/18b" "(null)" \
 573                 "$here/18b/.git" "(null)" "$here/18b/sub" "(null)"
 574 '
 575
 576 # Case #19: GIT_DIR + GIT_WORK_TREE suppresses bareness.
 577 test_expect_success '#19: setup' '
 578         setup_repo 19 unset "" true &&
 579         mkdir -p 19/sub/sub 19/wt/sub
 580 '
 581 run_wt_tests 19
 582
 583 test_expect_success '#20a: core.worktree without GIT_DIR accepted (inside .git)' '
 584         # Unlike case #16a.
 585         setup_repo 20a "$here/20a" "" unset &&
 586         mkdir -p 20a/.git/wt/sub &&
 587         try_case 20a/.git unset unset \
 588                 "$here/20a/.git" "$here/20a" "$here/20a" .git/ 2>message &&
 589         try_case 20a/.git/wt unset unset \
 590                 "$here/20a/.git" "$here/20a" "$here/20a" .git/wt/ &&
 591         try_case 20a/.git/wt/sub unset unset \
 592                 "$here/20a/.git" "$here/20a" "$here/20a" .git/wt/sub/ &&
 593         ! test -s message
 594 '
 595
 596 test_expect_success '#20b/c: core.worktree and core.bare conflict' '
 597         setup_repo 20b non-existent "" true &&
 598         mkdir -p 20b/.git/wt/sub &&
 599         (
 600                 cd 20b/.git &&
 601                 test_must_fail git status >/dev/null
 602         ) 2>message &&
 603         grep "core.bare and core.worktree" message
 604 '
 605
 606 test_expect_success '#20d: core.worktree and core.bare OK when working tree not needed' '
 607         setup_repo 20d non-existent "" true &&
 608         mkdir -p 20d/.git/wt/sub &&
 609         (
 610                 cd 20d/.git &&
 611                 git config foo.bar value
 612         )
 613 '
 614
 615 # Case #21: core.worktree/GIT_WORK_TREE overrides core.bare' '
 616 test_expect_success '#21: setup, core.worktree warns before overriding core.bare' '
 617         setup_repo 21 non-existent "" unset &&
 618         mkdir -p 21/.git/wt/sub &&
 619         (
 620                 cd 21/.git &&
 621                 GIT_WORK_TREE="$here/21" &&
 622                 export GIT_WORK_TREE &&
 623                 git status >/dev/null
 624         ) 2>message &&
 625         ! test -s message
 626
 627 '
 628 run_wt_tests 21
 629
 630 test_expect_success '#22a: core.worktree = GIT_DIR = .git dir' '
 631         # like case #6.
 632
 633         setup_repo 22a "$here/22a/.git" "" unset &&
 634         setup_repo 22ab . "" unset &&
 635         mkdir -p 22a/.git/sub 22a/sub &&
 636         mkdir -p 22ab/.git/sub 22ab/sub &&
 637         try_case 22a/.git unset . \
 638                 . "$here/22a/.git" "$here/22a/.git" "(null)" &&
 639         try_case 22a/.git unset "$here/22a/.git" \
 640                 "$here/22a/.git" "$here/22a/.git" "$here/22a/.git" "(null)" &&
 641         try_case 22a/.git/sub unset .. \
 642                 "$here/22a/.git" "$here/22a/.git" "$here/22a/.git" sub/ &&
 643         try_case 22a/.git/sub unset "$here/22a/.git" \
 644                 "$here/22a/.git" "$here/22a/.git" "$here/22a/.git" sub/ &&
 645
 646         try_case 22ab/.git unset . \
 647                 . "$here/22ab/.git" "$here/22ab/.git" "(null)" &&
 648         try_case 22ab/.git unset "$here/22ab/.git" \
 649                 "$here/22ab/.git" "$here/22ab/.git" "$here/22ab/.git" "(null)" &&
 650         try_case 22ab/.git/sub unset .. \
 651                 "$here/22ab/.git" "$here/22ab/.git" "$here/22ab/.git" sub/ &&
 652         try_case 22ab/.git unset "$here/22ab/.git" \
 653                 "$here/22ab/.git" "$here/22ab/.git" "$here/22ab/.git" "(null)"
 654 '
 655
 656 test_expect_success '#22b: core.worktree child of .git, GIT_DIR=.git' '
 657         setup_repo 22b "$here/22b/.git/wt" "" unset &&
 658         setup_repo 22bb wt "" unset &&
 659         mkdir -p 22b/.git/sub 22b/sub 22b/.git/wt/sub 22b/wt/sub &&
 660         mkdir -p 22bb/.git/sub 22bb/sub 22bb/.git/wt 22bb/wt &&
 661
 662         try_case 22b/.git unset . \
 663                 . "$here/22b/.git/wt" "$here/22b/.git" "(null)" &&
 664         try_case 22b/.git unset "$here/22b/.git" \
 665                 "$here/22b/.git" "$here/22b/.git/wt" "$here/22b/.git" "(null)" &&
 666         try_case 22b/.git/sub unset .. \
 667                 .. "$here/22b/.git/wt" "$here/22b/.git/sub" "(null)" &&
 668         try_case 22b/.git/sub unset "$here/22b/.git" \
 669                 "$here/22b/.git" "$here/22b/.git/wt" "$here/22b/.git/sub" "(null)" &&
 670
 671         try_case 22bb/.git unset . \
 672                 . "$here/22bb/.git/wt" "$here/22bb/.git" "(null)" &&
 673         try_case 22bb/.git unset "$here/22bb/.git" \
 674                 "$here/22bb/.git" "$here/22bb/.git/wt" "$here/22bb/.git" "(null)" &&
 675         try_case 22bb/.git/sub unset .. \
 676                 .. "$here/22bb/.git/wt" "$here/22bb/.git/sub" "(null)" &&
 677         try_case 22bb/.git/sub unset "$here/22bb/.git" \
 678                 "$here/22bb/.git" "$here/22bb/.git/wt" "$here/22bb/.git/sub" "(null)"
 679 '
 680
 681 test_expect_success '#22c: core.worktree = .git/.., GIT_DIR=.git' '
 682         setup_repo 22c "$here/22c" "" unset &&
 683         setup_repo 22cb .. "" unset &&
 684         mkdir -p 22c/.git/sub 22c/sub &&
 685         mkdir -p 22cb/.git/sub 22cb/sub &&
 686
 687         try_case 22c/.git unset . \
 688                 "$here/22c/.git" "$here/22c" "$here/22c" .git/ &&
 689         try_case 22c/.git unset "$here/22c/.git" \
 690                 "$here/22c/.git" "$here/22c" "$here/22c" .git/ &&
 691         try_case 22c/.git/sub unset .. \
 692                 "$here/22c/.git" "$here/22c" "$here/22c" .git/sub/ &&
 693         try_case 22c/.git/sub unset "$here/22c/.git" \
 694                 "$here/22c/.git" "$here/22c" "$here/22c" .git/sub/ &&
 695
 696         try_case 22cb/.git unset . \
 697                 "$here/22cb/.git" "$here/22cb" "$here/22cb" .git/ &&
 698         try_case 22cb/.git unset "$here/22cb/.git" \
 699                 "$here/22cb/.git" "$here/22cb" "$here/22cb" .git/ &&
 700         try_case 22cb/.git/sub unset .. \
 701                 "$here/22cb/.git" "$here/22cb" "$here/22cb" .git/sub/ &&
 702         try_case 22cb/.git/sub unset "$here/22cb/.git" \
 703                 "$here/22cb/.git" "$here/22cb" "$here/22cb" .git/sub/
 704 '
 705
 706 test_expect_success '#22.2: core.worktree and core.bare conflict' '
 707         setup_repo 22 "$here/22" "" true &&
 708         (
 709                 cd 22/.git &&
 710                 GIT_DIR=. &&
 711                 export GIT_DIR &&
 712                 test_must_fail git status 2>result
 713         ) &&
 714         (
 715                 cd 22 &&
 716                 GIT_DIR=.git &&
 717                 export GIT_DIR &&
 718                 test_must_fail git status 2>result
 719         ) &&
 720         grep "core.bare and core.worktree" 22/.git/result &&
 721         grep "core.bare and core.worktree" 22/result
 722 '
 723
 724 # Case #23: GIT_DIR + GIT_WORK_TREE(+core.worktree) suppresses bareness.
 725 test_expect_success '#23: setup' '
 726         setup_repo 23 non-existent "" true &&
 727         mkdir -p 23/sub/sub 23/wt/sub
 728 '
 729 run_wt_tests 23
 730
 731 test_expect_success '#24: bare repo has no worktree (gitfile case)' '
 732         try_repo 24 unset unset unset gitfile true \
 733                 "$here/24.git" "(null)" "$here/24" "(null)" \
 734                 "$here/24.git" "(null)" "$here/24/sub" "(null)"
 735 '
 736
 737 test_expect_success '#25: GIT_WORK_TREE accepted if GIT_DIR unset (bare gitfile case)' '
 738         try_repo 25 "$here/25" unset unset gitfile true \
 739                 "$here/25.git" "$here/25" "$here/25" "(null)"  \
 740                 "$here/25.git" "$here/25" "$here/25" "sub/" 2>message &&
 741         ! test -s message
 742 '
 743
 744 test_expect_success '#26: bare repo has no worktree (GIT_DIR -> gitfile case)' '
 745         try_repo 26 unset "$here/26/.git" unset gitfile true \
 746                 "$here/26.git" "(null)" "$here/26" "(null)" \
 747                 "$here/26.git" "(null)" "$here/26/sub" "(null)" &&
 748         try_repo 26b unset .git unset gitfile true \
 749                 "$here/26b.git" "(null)" "$here/26b" "(null)" \
 750                 "$here/26b.git" "(null)" "$here/26b/sub" "(null)"
 751 '
 752
 753 # Case #27: GIT_DIR + GIT_WORK_TREE suppresses bareness (with gitfile).
 754 test_expect_success '#27: setup' '
 755         setup_repo 27 unset gitfile true &&
 756         mkdir -p 27/sub/sub 27/wt/sub
 757 '
 758 run_wt_tests 27 gitfile
 759
 760 test_expect_success '#28: core.worktree and core.bare conflict (gitfile case)' '
 761         setup_repo 28 "$here/28" gitfile true &&
 762         (
 763                 cd 28 &&
 764                 test_must_fail git status
 765         ) 2>message &&
 766         grep "core.bare and core.worktree" message
 767 '
 768
 769 # Case #29: GIT_WORK_TREE(+core.worktree) overrides core.bare (gitfile case).
 770 test_expect_success '#29: setup' '
 771         setup_repo 29 non-existent gitfile true &&
 772         mkdir -p 29/sub/sub 29/wt/sub &&
 773         (
 774                 cd 29 &&
 775                 GIT_WORK_TREE="$here/29" &&
 776                 export GIT_WORK_TREE &&
 777                 git status
 778         ) 2>message &&
 779         ! test -s message
 780 '
 781 run_wt_tests 29 gitfile
 782
 783 test_expect_success '#30: core.worktree and core.bare conflict (gitfile version)' '
 784         # Just like case #22.
 785         setup_repo 30 "$here/30" gitfile true &&
 786         (
 787                 cd 30 &&
 788                 test_must_fail env GIT_DIR=.git git status 2>result
 789         ) &&
 790         grep "core.bare and core.worktree" 30/result
 791 '
 792
 793 # Case #31: GIT_DIR + GIT_WORK_TREE(+core.worktree) suppresses
 794 # bareness (gitfile version).
 795 test_expect_success '#31: setup' '
 796         setup_repo 31 non-existent gitfile true &&
 797         mkdir -p 31/sub/sub 31/wt/sub
 798 '
 799 run_wt_tests 31 gitfile
 800
 801 test_done