d499b2752e6ad4f4da6806f172d1c6ec7094aa57
1# Create a submodule layout used for all tests below.
2#
3# The following use cases are covered:
4# - New submodule (no_submodule => add_sub1)
5# - Removed submodule (add_sub1 => remove_sub1)
6# - Updated submodule (add_sub1 => modify_sub1)
7# - Submodule updated to invalid commit (add_sub1 => invalid_sub1)
8# - Submodule updated from invalid commit (invalid_sub1 => valid_sub1)
9# - Submodule replaced by tracked files in directory (add_sub1 =>
10# replace_sub1_with_directory)
11# - Directory containing tracked files replaced by submodule
12# (replace_sub1_with_directory => replace_directory_with_sub1)
13# - Submodule replaced by tracked file with the same name (add_sub1 =>
14# replace_sub1_with_file)
15# - Tracked file replaced by submodule (replace_sub1_with_file =>
16# replace_file_with_sub1)
17#
18# --O-----O
19# / ^ replace_directory_with_sub1
20# / replace_sub1_with_directory
21# /----O
22# / ^
23# / modify_sub1
24# O------O-------O
25# ^ ^\ ^
26# | | \ remove_sub1
27# | | -----O-----O
28# | | \ ^ replace_file_with_sub1
29# | | \ replace_sub1_with_file
30# | add_sub1 --O-----O
31# no_submodule ^ valid_sub1
32# invalid_sub1
33#
34create_lib_submodule_repo () {
35 git init submodule_update_repo &&
36 (
37 cd submodule_update_repo &&
38 echo "expect" >>.gitignore &&
39 echo "actual" >>.gitignore &&
40 echo "x" >file1 &&
41 echo "y" >file2 &&
42 git add .gitignore file1 file2 &&
43 git commit -m "Base" &&
44 git branch "no_submodule" &&
45 git checkout -b "add_sub1" &&
47 git submodule add ./. sub1 &&
48 git config -f .gitmodules submodule.sub1.ignore all &&
49 git config submodule.sub1.ignore all &&
50 git add .gitmodules &&
51 git commit -m "Add sub1" &&
52 git checkout -b remove_sub1 &&
53 git revert HEAD &&
54 git checkout -b "modify_sub1" "add_sub1" &&
56 git submodule update &&
57 (
58 cd sub1 &&
59 git fetch &&
60 git checkout -b "modifications" &&
61 echo "z" >file2 &&
62 echo "x" >file3 &&
63 git add file2 file3 &&
64 git commit -m "modified file2 and added file3" &&
65 git push origin modifications
66 ) &&
67 git add sub1 &&
68 git commit -m "Modify sub1" &&
69 git checkout -b "replace_sub1_with_directory" "add_sub1" &&
71 git submodule update &&
72 (
73 cd sub1 &&
74 git checkout modifications
75 ) &&
76 git rm --cached sub1 &&
77 rm sub1/.git* &&
78 git config -f .gitmodules --remove-section "submodule.sub1" &&
79 git add .gitmodules sub1/* &&
80 git commit -m "Replace sub1 with directory" &&
81 git checkout -b replace_directory_with_sub1 &&
82 git revert HEAD &&
83 git checkout -b "replace_sub1_with_file" "add_sub1" &&
85 git rm sub1 &&
86 echo "content" >sub1 &&
87 git add sub1 &&
88 git commit -m "Replace sub1 with file" &&
89 git checkout -b replace_file_with_sub1 &&
90 git revert HEAD &&
91 git checkout -b "invalid_sub1" "add_sub1" &&
93 git update-index --cacheinfo 160000 0123456789012345678901234567890123456789 sub1 &&
94 git commit -m "Invalid sub1 commit" &&
95 git checkout -b valid_sub1 &&
96 git revert HEAD &&
97 git checkout master
98 )
99}
100# Helper function to replace gitfile with .git directory
102replace_gitfile_with_git_dir () {
103 (
104 cd "$1" &&
105 git_dir="$(git rev-parse --git-dir)" &&
106 rm -f .git &&
107 cp -R "$git_dir" .git &&
108 GIT_WORK_TREE=. git config --unset core.worktree
109 )
110}
111# Test that the .git directory in the submodule is unchanged (except for the
113# core.worktree setting, which appears only in $GIT_DIR/modules/$1/config).
114# Call this function before test_submodule_content as the latter might
115# write the index file leading to false positive index differences.
116#
117# Note that this only supports submodules at the root level of the
118# superproject, with the default name, i.e. same as its path.
119test_git_directory_is_unchanged () {
120 (
121 cd ".git/modules/$1" &&
122 # does core.worktree point at the right place?
123 test "$(git config core.worktree)" = "../../../$1" &&
124 # remove it temporarily before comparing, as
125 # "$1/.git/config" lacks it...
126 git config --unset core.worktree
127 ) &&
128 diff -r ".git/modules/$1" "$1/.git" &&
129 (
130 # ... and then restore.
131 cd ".git/modules/$1" &&
132 git config core.worktree "../../../$1"
133 )
134}
135# Helper function to be executed at the start of every test below, it sets up
137# the submodule repo if it doesn't exist and configures the most problematic
138# settings for diff.ignoreSubmodules.
139prolog () {
140 (test -d submodule_update_repo || create_lib_submodule_repo) &&
141 test_config_global diff.ignoreSubmodules all &&
142 test_config diff.ignoreSubmodules all
143}
144# Helper function to bring work tree back into the state given by the
146# commit. This includes trying to populate sub1 accordingly if it exists and
147# should be updated to an existing commit.
148reset_work_tree_to () {
149 rm -rf submodule_update &&
150 git clone submodule_update_repo submodule_update &&
151 (
152 cd submodule_update &&
153 rm -rf sub1 &&
154 git checkout -f "$1" &&
155 git status -u -s >actual &&
156 test_must_be_empty actual &&
157 sha1=$(git rev-parse --revs-only HEAD:sub1) &&
158 if test -n "$sha1" &&
159 test $(cd "sub1" && git rev-parse --verify "$sha1^{commit}")
160 then
161 git submodule update --init --recursive "sub1"
162 fi
163 )
164}
165# Test that the superproject contains the content according to commit "$1"
167# (the work tree must match the index for everything but submodules but the
168# index must exactly match the given commit including any submodule SHA-1s).
169test_superproject_content () {
170 git diff-index --cached "$1" >actual &&
171 test_must_be_empty actual &&
172 git diff-files --ignore-submodules >actual &&
173 test_must_be_empty actual
174}
175# Test that the given submodule at path "$1" contains the content according
177# to the submodule commit recorded in the superproject's commit "$2"
178test_submodule_content () {
179 if test $# != 2
180 then
181 echo "test_submodule_content needs two arguments"
182 return 1
183 fi &&
184 submodule="$1" &&
185 commit="$2" &&
186 test -d "$submodule"/ &&
187 if ! test -f "$submodule"/.git && ! test -d "$submodule"/.git
188 then
189 echo "Submodule $submodule is not populated"
190 return 1
191 fi &&
192 sha1=$(git rev-parse --verify "$commit:$submodule") &&
193 if test -z "$sha1"
194 then
195 echo "Couldn't retrieve SHA-1 of $submodule for $commit"
196 return 1
197 fi &&
198 (
199 cd "$submodule" &&
200 git status -u -s >actual &&
201 test_must_be_empty actual &&
202 git diff "$sha1" >actual &&
203 test_must_be_empty actual
204 )
205}
206# Test that the following transitions are correctly handled:
208# - Updated submodule
209# - New submodule
210# - Removed submodule
211# - Directory containing tracked files replaced by submodule
212# - Submodule replaced by tracked files in directory
213# - Submodule replaced by tracked file with the same name
214# - tracked file replaced by submodule
215#
216# The default is that submodule contents aren't changed until "git submodule
217# update" is run. And even then that command doesn't delete the work tree of
218# a removed submodule.
219#
220# Removing a submodule containing a .git directory must fail even when forced
221# to protect the history!
222#
223# Test that submodule contents are currently not updated when switching
225# between commits that change a submodule.
226test_submodule_switch () {
227 command="$1"
228 ######################### Appearing submodule #########################
229 # Switching to a commit letting a submodule appear creates empty dir ...
230 test_expect_success "$command: added submodule creates empty directory" '
231 prolog &&
232 reset_work_tree_to no_submodule &&
233 (
234 cd submodule_update &&
235 git branch -t add_sub1 origin/add_sub1 &&
236 $command add_sub1 &&
237 test_superproject_content origin/add_sub1 &&
238 test_dir_is_empty sub1 &&
239 git submodule update --init --recursive &&
240 test_submodule_content sub1 origin/add_sub1
241 )
242 '
243 # ... and doesn't care if it already exists ...
244 test_expect_success "$command: added submodule leaves existing empty directory alone" '
245 prolog &&
246 reset_work_tree_to no_submodule &&
247 (
248 cd submodule_update &&
249 mkdir sub1 &&
250 git branch -t add_sub1 origin/add_sub1 &&
251 $command add_sub1 &&
252 test_superproject_content origin/add_sub1 &&
253 test_dir_is_empty sub1 &&
254 git submodule update --init --recursive &&
255 test_submodule_content sub1 origin/add_sub1
256 )
257 '
258 # ... unless there is an untracked file in its place.
259 test_expect_success "$command: added submodule doesn't remove untracked unignored file with same name" '
260 prolog &&
261 reset_work_tree_to no_submodule &&
262 (
263 cd submodule_update &&
264 git branch -t add_sub1 origin/add_sub1 &&
265 >sub1 &&
266 test_must_fail $command add_sub1 &&
267 test_superproject_content origin/no_submodule &&
268 test_must_be_empty sub1
269 )
270 '
271 # Replacing a tracked file with a submodule produces an empty
272 # directory ...
273 test_expect_success "$command: replace tracked file with submodule creates empty directory" '
274 prolog &&
275 reset_work_tree_to replace_sub1_with_file &&
276 (
277 cd submodule_update &&
278 git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
279 $command replace_file_with_sub1 &&
280 test_superproject_content origin/replace_file_with_sub1 &&
281 test_dir_is_empty sub1 &&
282 git submodule update --init --recursive &&
283 test_submodule_content sub1 origin/replace_file_with_sub1
284 )
285 '
286 # ... as does removing a directory with tracked files with a
287 # submodule.
288 if test "$KNOWN_FAILURE_NOFF_MERGE_DOESNT_CREATE_EMPTY_SUBMODULE_DIR" = 1
289 then
290 # Non fast-forward merges fail with "Directory sub1 doesn't
291 # exist. sub1" because the empty submodule directory is not
292 # created
293 RESULT="failure"
294 else
295 RESULT="success"
296 fi
297 test_expect_$RESULT "$command: replace directory with submodule" '
298 prolog &&
299 reset_work_tree_to replace_sub1_with_directory &&
300 (
301 cd submodule_update &&
302 git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
303 $command replace_directory_with_sub1 &&
304 test_superproject_content origin/replace_directory_with_sub1 &&
305 test_dir_is_empty sub1 &&
306 git submodule update --init --recursive &&
307 test_submodule_content sub1 origin/replace_directory_with_sub1
308 )
309 '
310 ######################## Disappearing submodule #######################
312 # Removing a submodule doesn't remove its work tree ...
313 test_expect_success "$command: removed submodule leaves submodule directory and its contents in place" '
314 prolog &&
315 reset_work_tree_to add_sub1 &&
316 (
317 cd submodule_update &&
318 git branch -t remove_sub1 origin/remove_sub1 &&
319 $command remove_sub1 &&
320 test_superproject_content origin/remove_sub1 &&
321 test_submodule_content sub1 origin/add_sub1
322 )
323 '
324 # ... especially when it contains a .git directory.
325 test_expect_success "$command: removed submodule leaves submodule containing a .git directory alone" '
326 prolog &&
327 reset_work_tree_to add_sub1 &&
328 (
329 cd submodule_update &&
330 git branch -t remove_sub1 origin/remove_sub1 &&
331 replace_gitfile_with_git_dir sub1 &&
332 $command remove_sub1 &&
333 test_superproject_content origin/remove_sub1 &&
334 test_git_directory_is_unchanged sub1 &&
335 test_submodule_content sub1 origin/add_sub1
336 )
337 '
338 # Replacing a submodule with files in a directory must fail as the
339 # submodule work tree isn't removed ...
340 if test "$KNOWN_FAILURE_NOFF_MERGE_ATTEMPTS_TO_MERGE_REMOVED_SUBMODULE_FILES" = 1
341 then
342 # Non fast-forward merges attempt to merge the former
343 # submodule files with the newly checked out ones in the
344 # directory of the same name while it shouldn't.
345 RESULT="failure"
346 else
347 RESULT="success"
348 fi
349 test_expect_$RESULT "$command: replace submodule with a directory must fail" '
350 prolog &&
351 reset_work_tree_to add_sub1 &&
352 (
353 cd submodule_update &&
354 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
355 test_must_fail $command replace_sub1_with_directory &&
356 test_superproject_content origin/add_sub1 &&
357 test_submodule_content sub1 origin/add_sub1
358 )
359 '
360 # ... especially when it contains a .git directory.
361 test_expect_$RESULT "$command: replace submodule containing a .git directory with a directory must fail" '
362 prolog &&
363 reset_work_tree_to add_sub1 &&
364 (
365 cd submodule_update &&
366 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
367 replace_gitfile_with_git_dir sub1 &&
368 test_must_fail $command replace_sub1_with_directory &&
369 test_superproject_content origin/add_sub1 &&
370 test_git_directory_is_unchanged sub1 &&
371 test_submodule_content sub1 origin/add_sub1
372 )
373 '
374 # Replacing it with a file must fail as it could throw away any local
375 # work tree changes ...
376 test_expect_failure "$command: replace submodule with a file must fail" '
377 prolog &&
378 reset_work_tree_to add_sub1 &&
379 (
380 cd submodule_update &&
381 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
382 test_must_fail $command replace_sub1_with_file &&
383 test_superproject_content origin/add_sub1 &&
384 test_submodule_content sub1 origin/add_sub1
385 )
386 '
387 # ... or even destroy unpushed parts of submodule history if that
388 # still uses a .git directory.
389 test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
390 prolog &&
391 reset_work_tree_to add_sub1 &&
392 (
393 cd submodule_update &&
394 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
395 replace_gitfile_with_git_dir sub1 &&
396 test_must_fail $command replace_sub1_with_file &&
397 test_superproject_content origin/add_sub1 &&
398 test_git_directory_is_unchanged sub1 &&
399 test_submodule_content sub1 origin/add_sub1
400 )
401 '
402 ########################## Modified submodule #########################
404 # Updating a submodule sha1 doesn't update the submodule's work tree
405 if test "$KNOWN_FAILURE_CHERRY_PICK_SEES_EMPTY_COMMIT" = 1
406 then
407 # When cherry picking a SHA-1 update for an ignored submodule
408 # the commit incorrectly fails with "The previous cherry-pick
409 # is now empty, possibly due to conflict resolution."
410 RESULT="failure"
411 else
412 RESULT="success"
413 fi
414 test_expect_$RESULT "$command: modified submodule does not update submodule work tree" '
415 prolog &&
416 reset_work_tree_to add_sub1 &&
417 (
418 cd submodule_update &&
419 git branch -t modify_sub1 origin/modify_sub1 &&
420 $command modify_sub1 &&
421 test_superproject_content origin/modify_sub1 &&
422 test_submodule_content sub1 origin/add_sub1 &&
423 git submodule update &&
424 test_submodule_content sub1 origin/modify_sub1
425 )
426 '
427 # Updating a submodule to an invalid sha1 doesn't update the
429 # submodule's work tree, subsequent update will fail
430 test_expect_$RESULT "$command: modified submodule does not update submodule work tree to invalid commit" '
431 prolog &&
432 reset_work_tree_to add_sub1 &&
433 (
434 cd submodule_update &&
435 git branch -t invalid_sub1 origin/invalid_sub1 &&
436 $command invalid_sub1 &&
437 test_superproject_content origin/invalid_sub1 &&
438 test_submodule_content sub1 origin/add_sub1 &&
439 test_must_fail git submodule update &&
440 test_submodule_content sub1 origin/add_sub1
441 )
442 '
443 # Updating a submodule from an invalid sha1 doesn't update the
444 # submodule's work tree, subsequent update will succeed
445 test_expect_$RESULT "$command: modified submodule does not update submodule work tree from invalid commit" '
446 prolog &&
447 reset_work_tree_to invalid_sub1 &&
448 (
449 cd submodule_update &&
450 git branch -t valid_sub1 origin/valid_sub1 &&
451 $command valid_sub1 &&
452 test_superproject_content origin/valid_sub1 &&
453 test_dir_is_empty sub1 &&
454 git submodule update --init --recursive &&
455 test_submodule_content sub1 origin/valid_sub1
456 )
457 '
458}
459# Test that submodule contents are currently not updated when switching
461# between commits that change a submodule, but throwing away local changes in
462# the superproject is allowed.
463test_submodule_forced_switch () {
464 command="$1"
465 ######################### Appearing submodule #########################
466 # Switching to a commit letting a submodule appear creates empty dir ...
467 test_expect_success "$command: added submodule creates empty directory" '
468 prolog &&
469 reset_work_tree_to no_submodule &&
470 (
471 cd submodule_update &&
472 git branch -t add_sub1 origin/add_sub1 &&
473 $command add_sub1 &&
474 test_superproject_content origin/add_sub1 &&
475 test_dir_is_empty sub1 &&
476 git submodule update --init --recursive &&
477 test_submodule_content sub1 origin/add_sub1
478 )
479 '
480 # ... and doesn't care if it already exists ...
481 test_expect_success "$command: added submodule leaves existing empty directory alone" '
482 prolog &&
483 reset_work_tree_to no_submodule &&
484 (
485 cd submodule_update &&
486 git branch -t add_sub1 origin/add_sub1 &&
487 mkdir sub1 &&
488 $command add_sub1 &&
489 test_superproject_content origin/add_sub1 &&
490 test_dir_is_empty sub1 &&
491 git submodule update --init --recursive &&
492 test_submodule_content sub1 origin/add_sub1
493 )
494 '
495 # ... unless there is an untracked file in its place.
496 test_expect_success "$command: added submodule does remove untracked unignored file with same name when forced" '
497 prolog &&
498 reset_work_tree_to no_submodule &&
499 (
500 cd submodule_update &&
501 git branch -t add_sub1 origin/add_sub1 &&
502 >sub1 &&
503 $command add_sub1 &&
504 test_superproject_content origin/add_sub1 &&
505 test_dir_is_empty sub1
506 )
507 '
508 # Replacing a tracked file with a submodule produces an empty
509 # directory ...
510 test_expect_success "$command: replace tracked file with submodule creates empty directory" '
511 prolog &&
512 reset_work_tree_to replace_sub1_with_file &&
513 (
514 cd submodule_update &&
515 git branch -t replace_file_with_sub1 origin/replace_file_with_sub1 &&
516 $command replace_file_with_sub1 &&
517 test_superproject_content origin/replace_file_with_sub1 &&
518 test_dir_is_empty sub1 &&
519 git submodule update --init --recursive &&
520 test_submodule_content sub1 origin/replace_file_with_sub1
521 )
522 '
523 # ... as does removing a directory with tracked files with a
524 # submodule.
525 test_expect_success "$command: replace directory with submodule" '
526 prolog &&
527 reset_work_tree_to replace_sub1_with_directory &&
528 (
529 cd submodule_update &&
530 git branch -t replace_directory_with_sub1 origin/replace_directory_with_sub1 &&
531 $command replace_directory_with_sub1 &&
532 test_superproject_content origin/replace_directory_with_sub1 &&
533 test_dir_is_empty sub1 &&
534 git submodule update --init --recursive &&
535 test_submodule_content sub1 origin/replace_directory_with_sub1
536 )
537 '
538 ######################## Disappearing submodule #######################
540 # Removing a submodule doesn't remove its work tree ...
541 test_expect_success "$command: removed submodule leaves submodule directory and its contents in place" '
542 prolog &&
543 reset_work_tree_to add_sub1 &&
544 (
545 cd submodule_update &&
546 git branch -t remove_sub1 origin/remove_sub1 &&
547 $command remove_sub1 &&
548 test_superproject_content origin/remove_sub1 &&
549 test_submodule_content sub1 origin/add_sub1
550 )
551 '
552 # ... especially when it contains a .git directory.
553 test_expect_success "$command: removed submodule leaves submodule containing a .git directory alone" '
554 prolog &&
555 reset_work_tree_to add_sub1 &&
556 (
557 cd submodule_update &&
558 git branch -t remove_sub1 origin/remove_sub1 &&
559 replace_gitfile_with_git_dir sub1 &&
560 $command remove_sub1 &&
561 test_superproject_content origin/remove_sub1 &&
562 test_git_directory_is_unchanged sub1 &&
563 test_submodule_content sub1 origin/add_sub1
564 )
565 '
566 # Replacing a submodule with files in a directory must fail as the
567 # submodule work tree isn't removed ...
568 test_expect_failure "$command: replace submodule with a directory must fail" '
569 prolog &&
570 reset_work_tree_to add_sub1 &&
571 (
572 cd submodule_update &&
573 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
574 test_must_fail $command replace_sub1_with_directory &&
575 test_superproject_content origin/add_sub1 &&
576 test_submodule_content sub1 origin/add_sub1
577 )
578 '
579 # ... especially when it contains a .git directory.
580 test_expect_failure "$command: replace submodule containing a .git directory with a directory must fail" '
581 prolog &&
582 reset_work_tree_to add_sub1 &&
583 (
584 cd submodule_update &&
585 git branch -t replace_sub1_with_directory origin/replace_sub1_with_directory &&
586 replace_gitfile_with_git_dir sub1 &&
587 test_must_fail $command replace_sub1_with_directory &&
588 test_superproject_content origin/add_sub1 &&
589 test_git_directory_is_unchanged sub1 &&
590 test_submodule_content sub1 origin/add_sub1
591 )
592 '
593 # Replacing it with a file must fail as it could throw away any local
594 # work tree changes ...
595 test_expect_failure "$command: replace submodule with a file must fail" '
596 prolog &&
597 reset_work_tree_to add_sub1 &&
598 (
599 cd submodule_update &&
600 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
601 test_must_fail $command replace_sub1_with_file &&
602 test_superproject_content origin/add_sub1 &&
603 test_submodule_content sub1 origin/add_sub1
604 )
605 '
606 # ... or even destroy unpushed parts of submodule history if that
607 # still uses a .git directory.
608 test_expect_failure "$command: replace submodule containing a .git directory with a file must fail" '
609 prolog &&
610 reset_work_tree_to add_sub1 &&
611 (
612 cd submodule_update &&
613 git branch -t replace_sub1_with_file origin/replace_sub1_with_file &&
614 replace_gitfile_with_git_dir sub1 &&
615 test_must_fail $command replace_sub1_with_file &&
616 test_superproject_content origin/add_sub1 &&
617 test_git_directory_is_unchanged sub1 &&
618 test_submodule_content sub1 origin/add_sub1
619 )
620 '
621 ########################## Modified submodule #########################
623 # Updating a submodule sha1 doesn't update the submodule's work tree
624 test_expect_success "$command: modified submodule does not update submodule work tree" '
625 prolog &&
626 reset_work_tree_to add_sub1 &&
627 (
628 cd submodule_update &&
629 git branch -t modify_sub1 origin/modify_sub1 &&
630 $command modify_sub1 &&
631 test_superproject_content origin/modify_sub1 &&
632 test_submodule_content sub1 origin/add_sub1 &&
633 git submodule update &&
634 test_submodule_content sub1 origin/modify_sub1
635 )
636 '
637 # Updating a submodule to an invalid sha1 doesn't update the
638 # submodule's work tree, subsequent update will fail
639 test_expect_success "$command: modified submodule does not update submodule work tree to invalid commit" '
640 prolog &&
641 reset_work_tree_to add_sub1 &&
642 (
643 cd submodule_update &&
644 git branch -t invalid_sub1 origin/invalid_sub1 &&
645 $command invalid_sub1 &&
646 test_superproject_content origin/invalid_sub1 &&
647 test_submodule_content sub1 origin/add_sub1 &&
648 test_must_fail git submodule update &&
649 test_submodule_content sub1 origin/add_sub1
650 )
651 '
652 # Updating a submodule from an invalid sha1 doesn't update the
653 # submodule's work tree, subsequent update will succeed
654 test_expect_success "$command: modified submodule does not update submodule work tree from invalid commit" '
655 prolog &&
656 reset_work_tree_to invalid_sub1 &&
657 (
658 cd submodule_update &&
659 git branch -t valid_sub1 origin/valid_sub1 &&
660 $command valid_sub1 &&
661 test_superproject_content origin/valid_sub1 &&
662 test_dir_is_empty sub1 &&
663 git submodule update --init --recursive &&
664 test_submodule_content sub1 origin/valid_sub1
665 )
666 '
667}