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