summaryrefslogtreecommitdiff
path: root/t/t1092-sparse-checkout-compatibility.sh
blob: f3a059e5af557aacf113909aa06e089d9fd43e8c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
#!/bin/sh

test_description='compare full workdir to sparse workdir'

GIT_TEST_SPLIT_INDEX=0
GIT_TEST_SPARSE_INDEX=

. ./test-lib.sh

test_expect_success 'setup' '
	git init initial-repo &&
	(
		GIT_TEST_SPARSE_INDEX=0 &&
		cd initial-repo &&
		echo a >a &&
		echo "after deep" >e &&
		echo "after folder1" >g &&
		echo "after x" >z &&
		mkdir folder1 folder2 deep x &&
		mkdir deep/deeper1 deep/deeper2 deep/before deep/later &&
		mkdir deep/deeper1/deepest &&
		mkdir deep/deeper1/deepest2 &&
		mkdir deep/deeper1/deepest3 &&
		echo "after deeper1" >deep/e &&
		echo "after deepest" >deep/deeper1/e &&
		cp a folder1 &&
		cp a folder2 &&
		cp a x &&
		cp a deep &&
		cp a deep/before &&
		cp a deep/deeper1 &&
		cp a deep/deeper2 &&
		cp a deep/later &&
		cp a deep/deeper1/deepest &&
		cp a deep/deeper1/deepest2 &&
		cp a deep/deeper1/deepest3 &&
		cp -r deep/deeper1/ deep/deeper2 &&
		mkdir deep/deeper1/0 &&
		mkdir deep/deeper1/0/0 &&
		touch deep/deeper1/0/1 &&
		touch deep/deeper1/0/0/0 &&
		>folder1- &&
		>folder1.x &&
		>folder10 &&
		cp -r deep/deeper1/0 folder1 &&
		cp -r deep/deeper1/0 folder2 &&
		echo >>folder1/0/0/0 &&
		echo >>folder2/0/1 &&
		git add . &&
		git commit -m "initial commit" &&
		git checkout -b base &&
		for dir in folder1 folder2 deep
		do
			git checkout -b update-$dir base &&
			echo "updated $dir" >$dir/a &&
			git commit -a -m "update $dir" || return 1
		done &&

		git checkout -b rename-base base &&
		cat >folder1/larger-content <<-\EOF &&
		matching
		lines
		help
		inexact
		renames
		EOF
		cp folder1/larger-content folder2/ &&
		cp folder1/larger-content deep/deeper1/ &&
		git add . &&
		git commit -m "add interesting rename content" &&

		git checkout -b rename-out-to-out rename-base &&
		mv folder1/a folder2/b &&
		mv folder1/larger-content folder2/edited-content &&
		echo >>folder2/edited-content &&
		echo >>folder2/0/1 &&
		echo stuff >>deep/deeper1/a &&
		git add . &&
		git commit -m "rename folder1/... to folder2/..." &&

		git checkout -b rename-out-to-in rename-base &&
		mv folder1/a deep/deeper1/b &&
		echo more stuff >>deep/deeper1/a &&
		rm folder2/0/1 &&
		mkdir folder2/0/1 &&
		echo >>folder2/0/1/1 &&
		mv folder1/larger-content deep/deeper1/edited-content &&
		echo >>deep/deeper1/edited-content &&
		git add . &&
		git commit -m "rename folder1/... to deep/deeper1/..." &&

		git checkout -b rename-in-to-out rename-base &&
		mv deep/deeper1/a folder1/b &&
		echo >>folder2/0/1 &&
		rm -rf folder1/0/0 &&
		echo >>folder1/0/0 &&
		mv deep/deeper1/larger-content folder1/edited-content &&
		echo >>folder1/edited-content &&
		git add . &&
		git commit -m "rename deep/deeper1/... to folder1/..." &&

		git checkout -b df-conflict-1 base &&
		rm -rf folder1 &&
		echo content >folder1 &&
		git add . &&
		git commit -m "dir to file" &&

		git checkout -b df-conflict-2 base &&
		rm -rf folder2 &&
		echo content >folder2 &&
		git add . &&
		git commit -m "dir to file" &&

		git checkout -b fd-conflict base &&
		rm a &&
		mkdir a &&
		echo content >a/a &&
		git add . &&
		git commit -m "file to dir" &&

		for side in left right
		do
			git checkout -b merge-$side base &&
			echo $side >>deep/deeper2/a &&
			echo $side >>folder1/a &&
			echo $side >>folder2/a &&
			git add . &&
			git commit -m "$side" || return 1
		done &&

		git checkout -b deepest base &&
		echo "updated deepest" >deep/deeper1/deepest/a &&
		echo "updated deepest2" >deep/deeper1/deepest2/a &&
		echo "updated deepest3" >deep/deeper1/deepest3/a &&
		git commit -a -m "update deepest" &&

		git checkout -f base &&
		git reset --hard
	)
'

init_repos () {
	rm -rf full-checkout sparse-checkout sparse-index &&

	# create repos in initial state
	cp -r initial-repo full-checkout &&
	git -C full-checkout reset --hard &&

	cp -r initial-repo sparse-checkout &&
	git -C sparse-checkout reset --hard &&

	cp -r initial-repo sparse-index &&
	git -C sparse-index reset --hard &&

	# initialize sparse-checkout definitions
	git -C sparse-checkout sparse-checkout init --cone &&
	git -C sparse-checkout sparse-checkout set deep &&
	git -C sparse-index sparse-checkout init --cone --sparse-index &&
	test_cmp_config -C sparse-index true index.sparse &&
	git -C sparse-index sparse-checkout set deep
}

run_on_sparse () {
	(
		cd sparse-checkout &&
		GIT_PROGRESS_DELAY=100000 "$@" >../sparse-checkout-out 2>../sparse-checkout-err
	) &&
	(
		cd sparse-index &&
		GIT_PROGRESS_DELAY=100000 "$@" >../sparse-index-out 2>../sparse-index-err
	)
}

run_on_all () {
	(
		cd full-checkout &&
		GIT_PROGRESS_DELAY=100000 "$@" >../full-checkout-out 2>../full-checkout-err
	) &&
	run_on_sparse "$@"
}

test_all_match () {
	run_on_all "$@" &&
	test_cmp full-checkout-out sparse-checkout-out &&
	test_cmp full-checkout-out sparse-index-out &&
	test_cmp full-checkout-err sparse-checkout-err &&
	test_cmp full-checkout-err sparse-index-err
}

test_sparse_match () {
	run_on_sparse "$@" &&
	test_cmp sparse-checkout-out sparse-index-out &&
	test_cmp sparse-checkout-err sparse-index-err
}

test_sparse_unstaged () {
	file=$1 &&
	for repo in sparse-checkout sparse-index
	do
		# Skip "unmerged" paths
		git -C $repo diff --staged --diff-filter=u -- "$file" >diff &&
		test_must_be_empty diff || return 1
	done
}

test_expect_success 'sparse-index contents' '
	init_repos &&

	git -C sparse-index ls-files --sparse --stage >cache &&
	for dir in folder1 folder2 x
	do
		TREE=$(git -C sparse-index rev-parse HEAD:$dir) &&
		grep "040000 $TREE 0	$dir/" cache \
			|| return 1
	done &&

	git -C sparse-index sparse-checkout set folder1 &&

	git -C sparse-index ls-files --sparse --stage >cache &&
	for dir in deep folder2 x
	do
		TREE=$(git -C sparse-index rev-parse HEAD:$dir) &&
		grep "040000 $TREE 0	$dir/" cache \
			|| return 1
	done &&

	git -C sparse-index sparse-checkout set deep/deeper1 &&

	git -C sparse-index ls-files --sparse --stage >cache &&
	for dir in deep/deeper2 folder1 folder2 x
	do
		TREE=$(git -C sparse-index rev-parse HEAD:$dir) &&
		grep "040000 $TREE 0	$dir/" cache \
			|| return 1
	done &&

	# Disabling the sparse-index replaces tree entries with full ones
	git -C sparse-index sparse-checkout init --no-sparse-index &&
	test_sparse_match git ls-files --stage --sparse
'

test_expect_success 'expanded in-memory index matches full index' '
	init_repos &&
	test_sparse_match git ls-files --stage
'

test_expect_success 'status with options' '
	init_repos &&
	test_sparse_match ls &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git status --porcelain=v2 -z -u &&
	test_all_match git status --porcelain=v2 -uno &&
	run_on_all touch README.md &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git status --porcelain=v2 -z -u &&
	test_all_match git status --porcelain=v2 -uno &&
	test_all_match git add README.md &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git status --porcelain=v2 -z -u &&
	test_all_match git status --porcelain=v2 -uno
'

test_expect_success 'status reports sparse-checkout' '
	init_repos &&
	git -C sparse-checkout status >full &&
	git -C sparse-index status >sparse &&
	test_i18ngrep "You are in a sparse checkout with " full &&
	test_i18ngrep "You are in a sparse checkout." sparse
'

test_expect_success 'add, commit, checkout' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF
	run_on_all ../edit-contents README.md &&

	test_all_match git add README.md &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git commit -m "Add README.md" &&

	test_all_match git checkout HEAD~1 &&
	test_all_match git checkout - &&

	run_on_all ../edit-contents README.md &&

	test_all_match git add -A &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git commit -m "Extend README.md" &&

	test_all_match git checkout HEAD~1 &&
	test_all_match git checkout - &&

	run_on_all ../edit-contents deep/newfile &&

	test_all_match git status --porcelain=v2 -uno &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git add . &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git commit -m "add deep/newfile" &&

	test_all_match git checkout HEAD~1 &&
	test_all_match git checkout -
'

test_expect_success 'deep changes during checkout' '
	init_repos &&

	test_sparse_match git sparse-checkout set deep/deeper1/deepest &&
	test_all_match git checkout deepest &&
	test_all_match git checkout base
'

test_expect_success 'add outside sparse cone' '
	init_repos &&

	run_on_sparse mkdir folder1 &&
	run_on_sparse ../edit-contents folder1/a &&
	run_on_sparse ../edit-contents folder1/newfile &&
	test_sparse_match test_must_fail git add folder1/a &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder1/a &&
	test_sparse_match test_must_fail git add folder1/newfile &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder1/newfile
'

test_expect_success 'commit including unstaged changes' '
	init_repos &&

	write_script edit-file <<-\EOF &&
	echo $1 >$2
	EOF

	run_on_all ../edit-file 1 a &&
	run_on_all ../edit-file 1 deep/a &&

	test_all_match git commit -m "-a" -a &&
	test_all_match git status --porcelain=v2 &&

	run_on_all ../edit-file 2 a &&
	run_on_all ../edit-file 2 deep/a &&

	test_all_match git commit -m "--include" --include deep/a &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git commit -m "--include" --include a &&
	test_all_match git status --porcelain=v2 &&

	run_on_all ../edit-file 3 a &&
	run_on_all ../edit-file 3 deep/a &&

	test_all_match git commit -m "--amend" -a --amend &&
	test_all_match git status --porcelain=v2
'

test_expect_success 'status/add: outside sparse cone' '
	init_repos &&

	# folder1 is at HEAD, but outside the sparse cone
	run_on_sparse mkdir folder1 &&
	cp initial-repo/folder1/a sparse-checkout/folder1/a &&
	cp initial-repo/folder1/a sparse-index/folder1/a &&

	test_sparse_match git status &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF
	run_on_sparse ../edit-contents folder1/a &&
	run_on_all ../edit-contents folder1/new &&

	test_sparse_match git status --porcelain=v2 &&

	# Adding the path outside of the sparse-checkout cone should fail.
	test_sparse_match test_must_fail git add folder1/a &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder1/a &&
	test_sparse_match test_must_fail git add --refresh folder1/a &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder1/a &&
	test_sparse_match test_must_fail git add folder1/new &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder1/new &&
	test_sparse_match git add --sparse folder1/a &&
	test_sparse_match git add --sparse folder1/new &&

	test_all_match git add --sparse . &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git commit -m folder1/new &&
	test_all_match git rev-parse HEAD^{tree} &&

	run_on_all ../edit-contents folder1/newer &&
	test_all_match git add --sparse folder1/ &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git commit -m folder1/newer &&
	test_all_match git rev-parse HEAD^{tree}
'

test_expect_success 'checkout and reset --hard' '
	init_repos &&

	test_all_match git checkout update-folder1 &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git checkout update-deep &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git checkout -b reset-test &&
	test_all_match git reset --hard deepest &&
	test_all_match git reset --hard update-folder1 &&
	test_all_match git reset --hard update-folder2
'

test_expect_success 'diff --cached' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>README.md
	EOF
	run_on_all ../edit-contents &&

	test_all_match git diff &&
	test_all_match git diff --cached &&
	test_all_match git add README.md &&
	test_all_match git diff &&
	test_all_match git diff --cached
'

# NEEDSWORK: sparse-checkout behaves differently from full-checkout when
# running this test with 'df-conflict-2' after 'df-conflict-1'.
test_expect_success 'diff with renames and conflicts' '
	init_repos &&

	for branch in rename-out-to-out \
		      rename-out-to-in \
		      rename-in-to-out \
		      df-conflict-1 \
		      fd-conflict
	do
		test_all_match git checkout rename-base &&
		test_all_match git checkout $branch -- . &&
		test_all_match git status --porcelain=v2 &&
		test_all_match git diff --cached --no-renames &&
		test_all_match git diff --cached --find-renames || return 1
	done
'

test_expect_success 'diff with directory/file conflicts' '
	init_repos &&

	for branch in rename-out-to-out \
		      rename-out-to-in \
		      rename-in-to-out \
		      df-conflict-1 \
		      df-conflict-2 \
		      fd-conflict
	do
		git -C full-checkout reset --hard &&
		test_sparse_match git reset --hard &&
		test_all_match git checkout $branch &&
		test_all_match git checkout rename-base -- . &&
		test_all_match git status --porcelain=v2 &&
		test_all_match git diff --cached --no-renames &&
		test_all_match git diff --cached --find-renames || return 1
	done
'

test_expect_success 'log with pathspec outside sparse definition' '
	init_repos &&

	test_all_match git log -- a &&
	test_all_match git log -- folder1/a &&
	test_all_match git log -- folder2/a &&
	test_all_match git log -- deep/a &&
	test_all_match git log -- deep/deeper1/a &&
	test_all_match git log -- deep/deeper1/deepest/a &&

	test_all_match git checkout update-folder1 &&
	test_all_match git log -- folder1/a
'

test_expect_success 'blame with pathspec inside sparse definition' '
	init_repos &&

	for file in a \
			deep/a \
			deep/deeper1/a \
			deep/deeper1/deepest/a
	do
		test_all_match git blame $file
	done
'

# Without a revision specified, blame will error if passed any file that
# is not present in the working directory (even if the file is tracked).
# Here we just verify that this is also true with sparse checkouts.
test_expect_success 'blame with pathspec outside sparse definition' '
	init_repos &&
	test_sparse_match git sparse-checkout set &&

	for file in a \
			deep/a \
			deep/deeper1/a \
			deep/deeper1/deepest/a
	do
		test_sparse_match test_must_fail git blame $file &&
		cat >expect <<-EOF &&
		fatal: Cannot lstat '"'"'$file'"'"': No such file or directory
		EOF
		# We compare sparse-checkout-err and sparse-index-err in
		# `test_sparse_match`. Given we know they are the same, we
		# only check the content of sparse-index-err here.
		test_cmp expect sparse-index-err
	done
'

test_expect_success 'checkout and reset (mixed)' '
	init_repos &&

	test_all_match git checkout -b reset-test update-deep &&
	test_all_match git reset deepest &&

	# Because skip-worktree is preserved, resetting to update-folder1
	# will show worktree changes for folder1/a in full-checkout, but not
	# in sparse-checkout or sparse-index.
	git -C full-checkout reset update-folder1 >full-checkout-out &&
	test_sparse_match git reset update-folder1 &&
	grep "M	folder1/a" full-checkout-out &&
	! grep "M	folder1/a" sparse-checkout-out &&
	run_on_sparse test_path_is_missing folder1
'

test_expect_success 'checkout and reset (merge)' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF

	test_all_match git checkout -b reset-test update-deep &&
	run_on_all ../edit-contents a &&
	test_all_match git reset --merge deepest &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git reset --hard update-deep &&
	run_on_all ../edit-contents deep/a &&
	test_all_match test_must_fail git reset --merge deepest
'

test_expect_success 'checkout and reset (keep)' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF

	test_all_match git checkout -b reset-test update-deep &&
	run_on_all ../edit-contents a &&
	test_all_match git reset --keep deepest &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git reset --hard update-deep &&
	run_on_all ../edit-contents deep/a &&
	test_all_match test_must_fail git reset --keep deepest
'

test_expect_success 'reset with pathspecs inside sparse definition' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF

	test_all_match git checkout -b reset-test update-deep &&
	run_on_all ../edit-contents deep/a &&

	test_all_match git reset base -- deep/a &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git reset base -- nonexistent-file &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git reset deepest -- deep &&
	test_all_match git status --porcelain=v2
'

# Although the working tree differs between full and sparse checkouts after
# reset, the state of the index is the same.
test_expect_success 'reset with pathspecs outside sparse definition' '
	init_repos &&
	test_all_match git checkout -b reset-test base &&

	test_sparse_match git reset update-folder1 -- folder1 &&
	git -C full-checkout reset update-folder1 -- folder1 &&
	test_all_match git ls-files -s -- folder1 &&

	test_sparse_match git reset update-folder2 -- folder2/a &&
	git -C full-checkout reset update-folder2 -- folder2/a &&
	test_all_match git ls-files -s -- folder2/a
'

test_expect_success 'reset with wildcard pathspec' '
	init_repos &&

	test_all_match git reset update-deep -- deep\* &&
	test_all_match git ls-files -s -- deep &&

	test_all_match git reset deepest -- deep\*\*\* &&
	test_all_match git ls-files -s -- deep &&

	# The following `git reset`s result in updating the index on files with
	# `skip-worktree` enabled. To avoid failing due to discrepencies in reported
	# "modified" files, `test_sparse_match` reset is performed separately from
	# "full-checkout" reset, then the index contents of all repos are verified.

	test_sparse_match git reset update-folder1 -- \*/a &&
	git -C full-checkout reset update-folder1 -- \*/a &&
	test_all_match git ls-files -s -- deep/a folder1/a &&

	test_sparse_match git reset update-folder2 -- folder\* &&
	git -C full-checkout reset update-folder2 -- folder\* &&
	test_all_match git ls-files -s -- folder10 folder1 folder2 &&

	test_sparse_match git reset base -- folder1/\* &&
	git -C full-checkout reset base -- folder1/\* &&
	test_all_match git ls-files -s -- folder1
'

test_expect_success 'update-index modify outside sparse definition' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF

	# Create & modify folder1/a
	# Note that this setup is a manual way of reaching the erroneous
	# condition in which a `skip-worktree` enabled, outside-of-cone file
	# exists on disk. It is used here to ensure `update-index` is stable
	# and behaves predictably if such a condition occurs.
	run_on_sparse mkdir -p folder1 &&
	run_on_sparse cp ../initial-repo/folder1/a folder1/a &&
	run_on_all ../edit-contents folder1/a &&

	# If file has skip-worktree enabled, update-index does not modify the
	# index entry
	test_sparse_match git update-index folder1/a &&
	test_sparse_match git status --porcelain=v2 &&
	test_must_be_empty sparse-checkout-out &&

	# When skip-worktree is disabled (even on files outside sparse cone), file
	# is updated in the index
	test_sparse_match git update-index --no-skip-worktree folder1/a &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git update-index folder1/a &&
	test_all_match git status --porcelain=v2
'

test_expect_success 'update-index --add outside sparse definition' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF

	# Create folder1, add new file
	run_on_sparse mkdir -p folder1 &&
	run_on_all ../edit-contents folder1/b &&

	# The *untracked* out-of-cone file is added to the index because it does
	# not have a `skip-worktree` bit to signal that it should be ignored
	# (unlike in `git add`, which will fail due to the file being outside
	# the sparse checkout definition).
	test_all_match git update-index --add folder1/b &&
	test_all_match git status --porcelain=v2
'

# NEEDSWORK: `--remove`, unlike the rest of `update-index`, does not ignore
# `skip-worktree` entries by default and will remove them from the index.
# The `--ignore-skip-worktree-entries` flag must be used in conjunction with
# `--remove` to ignore the `skip-worktree` entries and prevent their removal
# from the index.
test_expect_success 'update-index --remove outside sparse definition' '
	init_repos &&

	# When --ignore-skip-worktree-entries is _not_ specified:
	# out-of-cone, not-on-disk files are removed from the index
	test_sparse_match git update-index --remove folder1/a &&
	cat >expect <<-EOF &&
	D	folder1/a
	EOF
	test_sparse_match git diff --cached --name-status &&
	test_cmp expect sparse-checkout-out &&

	# Reset the state
	test_all_match git reset --hard &&

	# When --ignore-skip-worktree-entries is specified, out-of-cone
	# (skip-worktree) files are ignored
	test_sparse_match git update-index --remove --ignore-skip-worktree-entries folder1/a &&
	test_sparse_match git diff --cached --name-status &&
	test_must_be_empty sparse-checkout-out &&

	# Reset the state
	test_all_match git reset --hard &&

	# --force-remove supercedes --ignore-skip-worktree-entries, removing
	# a skip-worktree file from the index (and disk) when both are specified
	# with --remove
	test_sparse_match git update-index --force-remove --ignore-skip-worktree-entries folder1/a &&
	cat >expect <<-EOF &&
	D	folder1/a
	EOF
	test_sparse_match git diff --cached --name-status &&
	test_cmp expect sparse-checkout-out
'

test_expect_success 'update-index with directories' '
	init_repos &&

	# update-index will exit silently when provided with a directory name
	# containing a trailing slash
	test_all_match git update-index deep/ folder1/ &&
	grep "Ignoring path deep/" sparse-checkout-err &&
	grep "Ignoring path folder1/" sparse-checkout-err &&

	# When update-index is given a directory name WITHOUT a trailing slash, it will
	# behave in different ways depending on the status of the directory on disk:
	# * if it exists, the command exits with an error ("add individual files instead")
	# * if it does NOT exist (e.g., in a sparse-checkout), it is assumed to be a
	#   file and either triggers an error ("does not exist  and --remove not passed")
	#   or is ignored completely (when using --remove)
	test_all_match test_must_fail git update-index deep &&
	run_on_all test_must_fail git update-index folder1 &&
	test_must_fail git -C full-checkout update-index --remove folder1 &&
	test_sparse_match git update-index --remove folder1 &&
	test_all_match git status --porcelain=v2
'

test_expect_success 'update-index --again file outside sparse definition' '
	init_repos &&

	test_all_match git checkout -b test-reupdate &&

	# Update HEAD without modifying the index to introduce a difference in
	# folder1/a
	test_sparse_match git reset --soft update-folder1 &&

	# Because folder1/a differs in the index vs HEAD,
	# `git update-index --no-skip-worktree --again` will effectively perform
	# `git update-index --no-skip-worktree folder1/a` and remove the skip-worktree
	# flag from folder1/a
	test_sparse_match git update-index --no-skip-worktree --again &&
	test_sparse_match git status --porcelain=v2 &&

	cat >expect <<-EOF &&
	D	folder1/a
	EOF
	test_sparse_match git diff --name-status &&
	test_cmp expect sparse-checkout-out
'

test_expect_success 'update-index --cacheinfo' '
	init_repos &&

	deep_a_oid=$(git -C full-checkout rev-parse update-deep:deep/a) &&
	folder2_oid=$(git -C full-checkout rev-parse update-folder2:folder2) &&
	folder1_a_oid=$(git -C full-checkout rev-parse update-folder1:folder1/a) &&

	test_all_match git update-index --cacheinfo 100644 $deep_a_oid deep/a &&
	test_all_match git status --porcelain=v2 &&

	# Cannot add sparse directory, even in sparse index case
	test_all_match test_must_fail git update-index --add --cacheinfo 040000 $folder2_oid folder2/ &&

	# Sparse match only: the new outside-of-cone entry is added *without* skip-worktree,
	# so `git status` reports it as "deleted" in the worktree
	test_sparse_match git update-index --add --cacheinfo 100644 $folder1_a_oid folder1/a &&
	test_sparse_match git status --porcelain=v2 &&
	cat >expect <<-EOF &&
	MD folder1/a
	EOF
	test_sparse_match git status --short -- folder1/a &&
	test_cmp expect sparse-checkout-out &&

	# To return folder1/a to "normal" for a sparse checkout (ignored &
	# outside-of-cone), add the skip-worktree flag.
	test_sparse_match git update-index --skip-worktree folder1/a &&
	cat >expect <<-EOF &&
	S folder1/a
	EOF
	test_sparse_match git ls-files -t -- folder1/a &&
	test_cmp expect sparse-checkout-out
'

test_expect_success 'merge, cherry-pick, and rebase' '
	init_repos &&

	for OPERATION in "merge -m merge" cherry-pick "rebase --apply" "rebase --merge"
	do
		test_all_match git checkout -B temp update-deep &&
		test_all_match git $OPERATION update-folder1 &&
		test_all_match git rev-parse HEAD^{tree} &&
		test_all_match git $OPERATION update-folder2 &&
		test_all_match git rev-parse HEAD^{tree} || return 1
	done
'

test_expect_success 'merge with conflict outside cone' '
	init_repos &&

	test_all_match git checkout -b merge-tip merge-left &&
	test_all_match git status --porcelain=v2 &&
	test_all_match test_must_fail git merge -m merge merge-right &&
	test_all_match git status --porcelain=v2 &&

	# Resolve the conflict in different ways:
	# 1. Revert to the base
	test_all_match git checkout base -- deep/deeper2/a &&
	test_all_match git status --porcelain=v2 &&

	# 2. Add the file with conflict markers
	test_sparse_match test_must_fail git add folder1/a &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder1/a &&
	test_all_match git add --sparse folder1/a &&
	test_all_match git status --porcelain=v2 &&

	# 3. Rename the file to another sparse filename and
	#    accept conflict markers as resolved content.
	run_on_all mv folder2/a folder2/z &&
	test_sparse_match test_must_fail git add folder2 &&
	grep "Disable or modify the sparsity rules" sparse-checkout-err &&
	test_sparse_unstaged folder2/z &&
	test_all_match git add --sparse folder2 &&
	test_all_match git status --porcelain=v2 &&

	test_all_match git merge --continue &&
	test_all_match git status --porcelain=v2 &&
	test_all_match git rev-parse HEAD^{tree}
'

test_expect_success 'cherry-pick/rebase with conflict outside cone' '
	init_repos &&

	for OPERATION in cherry-pick rebase
	do
		test_all_match git checkout -B tip &&
		test_all_match git reset --hard merge-left &&
		test_all_match git status --porcelain=v2 &&
		test_all_match test_must_fail git $OPERATION merge-right &&
		test_all_match git status --porcelain=v2 &&

		# Resolve the conflict in different ways:
		# 1. Revert to the base
		test_all_match git checkout base -- deep/deeper2/a &&
		test_all_match git status --porcelain=v2 &&

		# 2. Add the file with conflict markers
		# NEEDSWORK: Even though the merge conflict removed the
		# SKIP_WORKTREE bit from the index entry for folder1/a, we should
		# warn that this is a problematic add.
		test_sparse_match test_must_fail git add folder1/a &&
		grep "Disable or modify the sparsity rules" sparse-checkout-err &&
		test_sparse_unstaged folder1/a &&
		test_all_match git add --sparse folder1/a &&
		test_all_match git status --porcelain=v2 &&

		# 3. Rename the file to another sparse filename and
		#    accept conflict markers as resolved content.
		# NEEDSWORK: This mode now fails, because folder2/z is
		# outside of the sparse-checkout cone and does not match an
		# existing index entry with the SKIP_WORKTREE bit cleared.
		run_on_all mv folder2/a folder2/z &&
		test_sparse_match test_must_fail git add folder2 &&
		grep "Disable or modify the sparsity rules" sparse-checkout-err &&
		test_sparse_unstaged folder2/z &&
		test_all_match git add --sparse folder2 &&
		test_all_match git status --porcelain=v2 &&

		test_all_match git $OPERATION --continue &&
		test_all_match git status --porcelain=v2 &&
		test_all_match git rev-parse HEAD^{tree} || return 1
	done
'

test_expect_success 'merge with outside renames' '
	init_repos &&

	for type in out-to-out out-to-in in-to-out
	do
		test_all_match git reset --hard &&
		test_all_match git checkout -f -b merge-$type update-deep &&
		test_all_match git merge -m "$type" rename-$type &&
		test_all_match git rev-parse HEAD^{tree} || return 1
	done
'

# Sparse-index fails to convert the index in the
# final 'git cherry-pick' command.
test_expect_success 'cherry-pick with conflicts' '
	init_repos &&

	write_script edit-conflict <<-\EOF &&
	echo $1 >conflict
	EOF

	test_all_match git checkout -b to-cherry-pick &&
	run_on_all ../edit-conflict ABC &&
	test_all_match git add conflict &&
	test_all_match git commit -m "conflict to pick" &&

	test_all_match git checkout -B base HEAD~1 &&
	run_on_all ../edit-conflict DEF &&
	test_all_match git add conflict &&
	test_all_match git commit -m "conflict in base" &&

	test_all_match test_must_fail git cherry-pick to-cherry-pick
'

test_expect_success 'checkout-index inside sparse definition' '
	init_repos &&

	run_on_all rm -f deep/a &&
	test_all_match git checkout-index -- deep/a &&
	test_all_match git status --porcelain=v2 &&

	echo test >>new-a &&
	run_on_all cp ../new-a a &&
	test_all_match test_must_fail git checkout-index -- a &&
	test_all_match git checkout-index -f -- a &&
	test_all_match git status --porcelain=v2
'

test_expect_success 'checkout-index outside sparse definition' '
	init_repos &&

	# Without --ignore-skip-worktree-bits, outside-of-cone files will trigger
	# an error
	test_sparse_match test_must_fail git checkout-index -- folder1/a &&
	test_i18ngrep "folder1/a has skip-worktree enabled" sparse-checkout-err &&
	test_path_is_missing folder1/a &&

	# With --ignore-skip-worktree-bits, outside-of-cone files are checked out
	test_sparse_match git checkout-index --ignore-skip-worktree-bits -- folder1/a &&
	test_cmp sparse-checkout/folder1/a sparse-index/folder1/a &&
	test_cmp sparse-checkout/folder1/a full-checkout/folder1/a &&

	run_on_sparse rm -rf folder1 &&
	echo test >new-a &&
	run_on_sparse mkdir -p folder1 &&
	run_on_all cp ../new-a folder1/a &&

	test_all_match test_must_fail git checkout-index --ignore-skip-worktree-bits -- folder1/a &&
	test_all_match git checkout-index -f --ignore-skip-worktree-bits -- folder1/a &&
	test_cmp sparse-checkout/folder1/a sparse-index/folder1/a &&
	test_cmp sparse-checkout/folder1/a full-checkout/folder1/a
'

test_expect_success 'checkout-index with folders' '
	init_repos &&

	# Inside checkout definition
	test_all_match test_must_fail git checkout-index -f -- deep/ &&

	# Outside checkout definition
	# Note: although all tests fail (as expected), the messaging differs. For
	# non-sparse index checkouts, the error is that the "file" does not appear
	# in the index; for sparse checkouts, the error is explicitly that the
	# entry is a sparse directory.
	run_on_all test_must_fail git checkout-index -f -- folder1/ &&
	test_cmp full-checkout-err sparse-checkout-err &&
	! test_cmp full-checkout-err sparse-index-err &&
	grep "is a sparse directory" sparse-index-err
'

test_expect_success 'checkout-index --all' '
	init_repos &&

	test_all_match git checkout-index --all &&
	test_sparse_match test_path_is_missing folder1 &&

	# --ignore-skip-worktree-bits will cause `skip-worktree` files to be
	# checked out, causing the outside-of-cone `folder1` to exist on-disk
	test_all_match git checkout-index --ignore-skip-worktree-bits --all &&
	test_all_match test_path_exists folder1
'

test_expect_success 'clean' '
	init_repos &&

	echo bogus >>.gitignore &&
	run_on_all cp ../.gitignore . &&
	test_all_match git add .gitignore &&
	test_all_match git commit -m "ignore bogus files" &&

	run_on_sparse mkdir folder1 &&
	run_on_all mkdir -p deep/untracked-deep &&
	run_on_all touch folder1/bogus &&
	run_on_all touch folder1/untracked &&
	run_on_all touch deep/untracked-deep/bogus &&
	run_on_all touch deep/untracked-deep/untracked &&

	test_all_match git status --porcelain=v2 &&
	test_all_match git clean -f &&
	test_all_match git status --porcelain=v2 &&
	test_sparse_match ls &&
	test_sparse_match ls folder1 &&
	run_on_all test_path_exists folder1/bogus &&
	run_on_all test_path_is_missing folder1/untracked &&
	run_on_all test_path_exists deep/untracked-deep/bogus &&
	run_on_all test_path_exists deep/untracked-deep/untracked &&

	test_all_match git clean -fd &&
	test_all_match git status --porcelain=v2 &&
	test_sparse_match ls &&
	test_sparse_match ls folder1 &&
	run_on_all test_path_exists folder1/bogus &&
	run_on_all test_path_exists deep/untracked-deep/bogus &&
	run_on_all test_path_is_missing deep/untracked-deep/untracked &&

	test_all_match git clean -xf &&
	test_all_match git status --porcelain=v2 &&
	test_sparse_match ls &&
	test_sparse_match ls folder1 &&
	run_on_all test_path_is_missing folder1/bogus &&
	run_on_all test_path_exists deep/untracked-deep/bogus &&

	test_all_match git clean -xdf &&
	test_all_match git status --porcelain=v2 &&
	test_sparse_match ls &&
	test_sparse_match ls folder1 &&
	run_on_all test_path_is_missing deep/untracked-deep/bogus &&

	test_sparse_match test_path_is_dir folder1
'

test_expect_success 'submodule handling' '
	init_repos &&

	test_sparse_match git sparse-checkout add modules &&
	test_all_match mkdir modules &&
	test_all_match touch modules/a &&
	test_all_match git add modules &&
	test_all_match git commit -m "add modules directory" &&

	run_on_all git submodule add "$(pwd)/initial-repo" modules/sub &&
	test_all_match git commit -m "add submodule" &&

	# having a submodule prevents "modules" from collapse
	test_sparse_match git sparse-checkout set deep/deeper1 &&
	git -C sparse-index ls-files --sparse --stage >cache &&
	grep "100644 .*	modules/a" cache &&
	grep "160000 $(git -C initial-repo rev-parse HEAD) 0	modules/sub" cache
'

# When working with a sparse index, some commands will need to expand the
# index to operate properly. If those commands also write the index back
# to disk, they need to convert the index to sparse before writing.
# This test verifies that both of these events are logged in trace2 logs.
test_expect_success 'sparse-index is expanded and converted back' '
	init_repos &&

	GIT_TRACE2_EVENT="$(pwd)/trace2.txt" \
		git -C sparse-index reset -- folder1/a &&
	test_region index convert_to_sparse trace2.txt &&
	test_region index ensure_full_index trace2.txt &&

	# ls-files expands on read, but does not write.
	rm trace2.txt &&
	GIT_TRACE2_EVENT="$(pwd)/trace2.txt" GIT_TRACE2_EVENT_NESTING=10 \
		git -C sparse-index ls-files &&
	test_region index ensure_full_index trace2.txt
'

test_expect_success 'index.sparse disabled inline uses full index' '
	init_repos &&

	# When index.sparse is disabled inline with `git status`, the
	# index is expanded at the beginning of the execution then never
	# converted back to sparse. It is then written to disk as a full index.
	rm -f trace2.txt &&
	GIT_TRACE2_EVENT="$(pwd)/trace2.txt" GIT_TRACE2_EVENT_NESTING=10 \
		git -C sparse-index -c index.sparse=false status &&
	! test_region index convert_to_sparse trace2.txt &&
	test_region index ensure_full_index trace2.txt &&

	# Since index.sparse is set to true at a repo level, the index
	# is converted from full to sparse when read, then never expanded
	# over the course of `git status`. It is written to disk as a sparse
	# index.
	rm -f trace2.txt &&
	GIT_TRACE2_EVENT="$(pwd)/trace2.txt" GIT_TRACE2_EVENT_NESTING=10 \
		git -C sparse-index status &&
	test_region index convert_to_sparse trace2.txt &&
	! test_region index ensure_full_index trace2.txt &&

	# Now that the index has been written to disk as sparse, it is not
	# converted to sparse (or expanded to full) when read by `git status`.
	rm -f trace2.txt &&
	GIT_TRACE2_EVENT="$(pwd)/trace2.txt" GIT_TRACE2_EVENT_NESTING=10 \
		git -C sparse-index status &&
	! test_region index convert_to_sparse trace2.txt &&
	! test_region index ensure_full_index trace2.txt
'

ensure_not_expanded () {
	rm -f trace2.txt &&
	echo >>sparse-index/untracked.txt &&

	if test "$1" = "!"
	then
		shift &&
		test_must_fail env \
			GIT_TRACE2_EVENT="$(pwd)/trace2.txt" \
			git -C sparse-index "$@" || return 1
	else
		GIT_TRACE2_EVENT="$(pwd)/trace2.txt" \
			git -C sparse-index "$@" || return 1
	fi &&
	test_region ! index ensure_full_index trace2.txt
}

test_expect_success 'sparse-index is not expanded' '
	init_repos &&

	ensure_not_expanded status &&
	ensure_not_expanded ls-files --sparse &&
	ensure_not_expanded commit --allow-empty -m empty &&
	echo >>sparse-index/a &&
	ensure_not_expanded commit -a -m a &&
	echo >>sparse-index/a &&
	ensure_not_expanded commit --include a -m a &&
	echo >>sparse-index/deep/deeper1/a &&
	ensure_not_expanded commit --include deep/deeper1/a -m deeper &&
	ensure_not_expanded checkout rename-out-to-out &&
	ensure_not_expanded checkout - &&
	ensure_not_expanded switch rename-out-to-out &&
	ensure_not_expanded switch - &&
	ensure_not_expanded reset --hard &&
	ensure_not_expanded checkout rename-out-to-out -- deep/deeper1 &&
	ensure_not_expanded reset --hard &&
	ensure_not_expanded restore -s rename-out-to-out -- deep/deeper1 &&

	echo >>sparse-index/README.md &&
	ensure_not_expanded add -A &&
	echo >>sparse-index/extra.txt &&
	ensure_not_expanded add extra.txt &&
	echo >>sparse-index/untracked.txt &&
	ensure_not_expanded add . &&

	ensure_not_expanded checkout-index -f a &&
	ensure_not_expanded checkout-index -f --all &&
	for ref in update-deep update-folder1 update-folder2 update-deep
	do
		echo >>sparse-index/README.md &&
		ensure_not_expanded reset --hard $ref || return 1
	done &&

	ensure_not_expanded reset --mixed base &&
	ensure_not_expanded reset --hard update-deep &&
	ensure_not_expanded reset --keep base &&
	ensure_not_expanded reset --merge update-deep &&
	ensure_not_expanded reset --hard &&

	ensure_not_expanded reset base -- deep/a &&
	ensure_not_expanded reset base -- nonexistent-file &&
	ensure_not_expanded reset deepest -- deep &&

	# Although folder1 is outside the sparse definition, it exists as a
	# directory entry in the index, so the pathspec will not force the
	# index to be expanded.
	ensure_not_expanded reset deepest -- folder1 &&
	ensure_not_expanded reset deepest -- folder1/ &&

	# Wildcard identifies only in-cone files, no index expansion
	ensure_not_expanded reset deepest -- deep/\* &&

	# Wildcard identifies only full sparse directories, no index expansion
	ensure_not_expanded reset deepest -- folder\* &&

	ensure_not_expanded clean -fd &&

	ensure_not_expanded checkout -f update-deep &&
	test_config -C sparse-index pull.twohead ort &&
	(
		sane_unset GIT_TEST_MERGE_ALGORITHM &&
		for OPERATION in "merge -m merge" cherry-pick rebase
		do
			ensure_not_expanded merge -m merge update-folder1 &&
			ensure_not_expanded merge -m merge update-folder2 || return 1
		done
	)
'

test_expect_success 'sparse-index is not expanded: merge conflict in cone' '
	init_repos &&

	for side in right left
	do
		git -C sparse-index checkout -b expand-$side base &&
		echo $side >sparse-index/deep/a &&
		git -C sparse-index commit -a -m "$side" || return 1
	done &&

	(
		sane_unset GIT_TEST_MERGE_ALGORITHM &&
		git -C sparse-index config pull.twohead ort &&
		ensure_not_expanded ! merge -m merged expand-right
	)
'

test_expect_success 'sparse index is not expanded: diff' '
	init_repos &&

	write_script edit-contents <<-\EOF &&
	echo text >>$1
	EOF

	# Add file within cone
	test_sparse_match git sparse-checkout set deep &&
	run_on_all ../edit-contents deep/testfile &&
	test_all_match git add deep/testfile &&
	run_on_all ../edit-contents deep/testfile &&

	test_all_match git diff &&
	test_all_match git diff --cached &&
	ensure_not_expanded diff &&
	ensure_not_expanded diff --cached &&

	# Add file outside cone
	test_all_match git reset --hard &&
	run_on_all mkdir newdirectory &&
	run_on_all ../edit-contents newdirectory/testfile &&
	test_sparse_match git sparse-checkout set newdirectory &&
	test_all_match git add newdirectory/testfile &&
	run_on_all ../edit-contents newdirectory/testfile &&
	test_sparse_match git sparse-checkout set &&

	test_all_match git diff &&
	test_all_match git diff --cached &&
	ensure_not_expanded diff &&
	ensure_not_expanded diff --cached &&

	# Merge conflict outside cone
	# The sparse checkout will report a warning that is not in the
	# full checkout, so we use `run_on_all` instead of
	# `test_all_match`
	run_on_all git reset --hard &&
	test_all_match git checkout merge-left &&
	test_all_match test_must_fail git merge merge-right &&

	test_all_match git diff &&
	test_all_match git diff --cached &&
	ensure_not_expanded diff &&
	ensure_not_expanded diff --cached
'

test_expect_success 'sparse index is not expanded: update-index' '
	init_repos &&

	deep_a_oid=$(git -C full-checkout rev-parse update-deep:deep/a) &&
	ensure_not_expanded update-index --cacheinfo 100644 $deep_a_oid deep/a &&

	echo "test" >sparse-index/README.md &&
	echo "test2" >sparse-index/a &&
	rm -f sparse-index/deep/a &&

	ensure_not_expanded update-index --add README.md &&
	ensure_not_expanded update-index a &&
	ensure_not_expanded update-index --remove deep/a &&

	ensure_not_expanded reset --soft update-deep &&
	ensure_not_expanded update-index --add --remove --again
'

test_expect_success 'sparse index is not expanded: blame' '
	init_repos &&

	for file in a \
			deep/a \
			deep/deeper1/a \
			deep/deeper1/deepest/a
	do
		ensure_not_expanded blame $file
	done
'

test_expect_success 'sparse index is not expanded: fetch/pull' '
	init_repos &&

	git -C sparse-index remote add full "file://$(pwd)/full-checkout" &&
	ensure_not_expanded fetch full &&
	git -C full-checkout commit --allow-empty -m "for pull merge" &&
	git -C sparse-index commit --allow-empty -m "for pull merge" &&
	ensure_not_expanded pull full base
'

test_expect_success 'ls-files' '
	init_repos &&

	# Use a smaller sparse-checkout for reduced output
	test_sparse_match git sparse-checkout set &&

	# Behavior agrees by default. Sparse index is expanded.
	test_all_match git ls-files &&

	# With --sparse, the sparse index data changes behavior.
	git -C sparse-index ls-files --sparse >actual &&

	cat >expect <<-\EOF &&
	a
	deep/
	e
	folder1-
	folder1.x
	folder1/
	folder10
	folder2/
	g
	x/
	z
	EOF

	test_cmp expect actual &&

	# With --sparse and no sparse index, nothing changes.
	git -C sparse-checkout ls-files >dense &&
	git -C sparse-checkout ls-files --sparse >sparse &&
	test_cmp dense sparse &&

	# Set up a strange condition of having a file edit
	# outside of the sparse-checkout cone. This is just
	# to verify that sparse-checkout and sparse-index
	# behave the same in this case.
	write_script edit-content <<-\EOF &&
	mkdir folder1 &&
	echo content >>folder1/a
	EOF
	run_on_sparse ../edit-content &&

	# ls-files does not currently notice modified files whose
	# cache entries are marked SKIP_WORKTREE. This may change
	# in the future, but here we test that sparse index does
	# not accidentally create a change of behavior.
	test_sparse_match git ls-files --modified &&
	test_must_be_empty sparse-checkout-out &&
	test_must_be_empty sparse-index-out &&

	git -C sparse-index ls-files --sparse --modified >sparse-index-out &&
	test_must_be_empty sparse-index-out &&

	# Add folder1 to the sparse-checkout cone and
	# check that ls-files shows the expanded files.
	test_sparse_match git sparse-checkout add folder1 &&
	test_sparse_match git ls-files --modified &&

	test_all_match git ls-files &&
	git -C sparse-index ls-files --sparse >actual &&

	cat >expect <<-\EOF &&
	a
	deep/
	e
	folder1-
	folder1.x
	folder1/0/0/0
	folder1/0/1
	folder1/a
	folder10
	folder2/
	g
	x/
	z
	EOF

	test_cmp expect actual &&

	# Double-check index expansion is avoided
	ensure_not_expanded ls-files --sparse
'

# NEEDSWORK: a sparse-checkout behaves differently from a full checkout
# in this scenario, but it shouldn't.
test_expect_success 'reset mixed and checkout orphan' '
	init_repos &&

	test_all_match git checkout rename-out-to-in &&

	# Sparse checkouts do not agree with full checkouts about
	# how to report a directory/file conflict during a reset.
	# This command would fail with test_all_match because the
	# full checkout reports "T folder1/0/1" while a sparse
	# checkout reports "D folder1/0/1". This matches because
	# the sparse checkouts skip "adding" the other side of
	# the conflict.
	test_sparse_match git reset --mixed HEAD~1 &&
	test_sparse_match git ls-files --stage &&
	test_sparse_match git status --porcelain=v2 &&

	# At this point, sparse-checkouts behave differently
	# from the full-checkout.
	test_sparse_match git checkout --orphan new-branch &&
	test_sparse_match git ls-files --stage &&
	test_sparse_match git status --porcelain=v2
'

test_expect_success 'add everything with deep new file' '
	init_repos &&

	run_on_sparse git sparse-checkout set deep/deeper1/deepest &&

	run_on_all touch deep/deeper1/x &&
	test_all_match git add . &&
	test_all_match git status --porcelain=v2
'

# NEEDSWORK: 'git checkout' behaves incorrectly in the case of
# directory/file conflicts, even without sparse-checkout. Use this
# test only as a documentation of the incorrect behavior, not a
# measure of how it _should_ behave.
test_expect_success 'checkout behaves oddly with df-conflict-1' '
	init_repos &&

	test_sparse_match git sparse-checkout disable &&

	write_script edit-content <<-\EOF &&
	echo content >>folder1/larger-content
	git add folder1
	EOF

	run_on_all ../edit-content &&
	test_all_match git status --porcelain=v2 &&

	git -C sparse-checkout sparse-checkout init --cone &&
	git -C sparse-index sparse-checkout init --cone --sparse-index &&

	test_all_match git status --porcelain=v2 &&

	# This checkout command should fail, because we have a staged
	# change to folder1/larger-content, but the destination changes
	# folder1 to a file.
	git -C full-checkout checkout df-conflict-1 \
		1>full-checkout-out \
		2>full-checkout-err &&
	git -C sparse-checkout checkout df-conflict-1 \
		1>sparse-checkout-out \
		2>sparse-checkout-err &&
	git -C sparse-index checkout df-conflict-1 \
		1>sparse-index-out \
		2>sparse-index-err &&

	# Instead, the checkout deletes the folder1 file and adds the
	# folder1/larger-content file, leaving all other paths that were
	# in folder1/ as deleted (without any warning).
	cat >expect <<-EOF &&
	D	folder1
	A	folder1/larger-content
	EOF
	test_cmp expect full-checkout-out &&
	test_cmp expect sparse-checkout-out &&

	# The sparse-index reports no output
	test_must_be_empty sparse-index-out &&

	# stderr: Switched to branch df-conflict-1
	test_cmp full-checkout-err sparse-checkout-err &&
	test_cmp full-checkout-err sparse-checkout-err
'

# NEEDSWORK: 'git checkout' behaves incorrectly in the case of
# directory/file conflicts, even without sparse-checkout. Use this
# test only as a documentation of the incorrect behavior, not a
# measure of how it _should_ behave.
test_expect_success 'checkout behaves oddly with df-conflict-2' '
	init_repos &&

	test_sparse_match git sparse-checkout disable &&

	write_script edit-content <<-\EOF &&
	echo content >>folder2/larger-content
	git add folder2
	EOF

	run_on_all ../edit-content &&
	test_all_match git status --porcelain=v2 &&

	git -C sparse-checkout sparse-checkout init --cone &&
	git -C sparse-index sparse-checkout init --cone --sparse-index &&

	test_all_match git status --porcelain=v2 &&

	# This checkout command should fail, because we have a staged
	# change to folder1/larger-content, but the destination changes
	# folder1 to a file.
	git -C full-checkout checkout df-conflict-2 \
		1>full-checkout-out \
		2>full-checkout-err &&
	git -C sparse-checkout checkout df-conflict-2 \
		1>sparse-checkout-out \
		2>sparse-checkout-err &&
	git -C sparse-index checkout df-conflict-2 \
		1>sparse-index-out \
		2>sparse-index-err &&

	# The full checkout deviates from the df-conflict-1 case here!
	# It drops the change to folder1/larger-content and leaves the
	# folder1 path as-is on disk. The sparse-index behaves the same.
	test_must_be_empty full-checkout-out &&
	test_must_be_empty sparse-index-out &&

	# In the sparse-checkout case, the checkout deletes the folder1
	# file and adds the folder1/larger-content file, leaving all other
	# paths that were in folder1/ as deleted (without any warning).
	cat >expect <<-EOF &&
	D	folder2
	A	folder2/larger-content
	EOF
	test_cmp expect sparse-checkout-out &&

	# Switched to branch df-conflict-1
	test_cmp full-checkout-err sparse-checkout-err &&
	test_cmp full-checkout-err sparse-index-err
'

test_done