Merge branch 'pw/add-p-recount' into maint
[git] / t / t5320-delta-islands.sh
1 #!/bin/sh
2
3 test_description='exercise delta islands'
4 . ./test-lib.sh
5
6 # returns true iff $1 is a delta based on $2
7 is_delta_base () {
8         delta_base=$(echo "$1" | git cat-file --batch-check='%(deltabase)') &&
9         echo >&2 "$1 has base $delta_base" &&
10         test "$delta_base" = "$2"
11 }
12
13 # generate a commit on branch $1 with a single file, "file", whose
14 # content is mostly based on the seed $2, but with a unique bit
15 # of content $3 appended. This should allow us to see whether
16 # blobs of different refs delta against each other.
17 commit() {
18         blob=$({ test-tool genrandom "$2" 10240 && echo "$3"; } |
19                git hash-object -w --stdin) &&
20         tree=$(printf '100644 blob %s\tfile\n' "$blob" | git mktree) &&
21         commit=$(echo "$2-$3" | git commit-tree "$tree" ${4:+-p "$4"}) &&
22         git update-ref "refs/heads/$1" "$commit" &&
23         eval "$1"'=$(git rev-parse $1:file)' &&
24         eval "echo >&2 $1=\$$1"
25 }
26
27 test_expect_success 'setup commits' '
28         commit one seed 1 &&
29         commit two seed 12
30 '
31
32 # Note: This is heavily dependent on the "prefer larger objects as base"
33 # heuristic.
34 test_expect_success 'vanilla repack deltas one against two' '
35         git repack -adf &&
36         is_delta_base $one $two
37 '
38
39 test_expect_success 'island repack with no island definition is vanilla' '
40         git repack -adfi &&
41         is_delta_base $one $two
42 '
43
44 test_expect_success 'island repack with no matches is vanilla' '
45         git -c "pack.island=refs/foo" repack -adfi &&
46         is_delta_base $one $two
47 '
48
49 test_expect_success 'separate islands disallows delta' '
50         git -c "pack.island=refs/heads/(.*)" repack -adfi &&
51         ! is_delta_base $one $two &&
52         ! is_delta_base $two $one
53 '
54
55 test_expect_success 'same island allows delta' '
56         git -c "pack.island=refs/heads" repack -adfi &&
57         is_delta_base $one $two
58 '
59
60 test_expect_success 'coalesce same-named islands' '
61         git \
62                 -c "pack.island=refs/(.*)/one" \
63                 -c "pack.island=refs/(.*)/two" \
64                 repack -adfi &&
65         is_delta_base $one $two
66 '
67
68 test_expect_success 'island restrictions drop reused deltas' '
69         git repack -adfi &&
70         is_delta_base $one $two &&
71         git -c "pack.island=refs/heads/(.*)" repack -adi &&
72         ! is_delta_base $one $two &&
73         ! is_delta_base $two $one
74 '
75
76 test_expect_success 'island regexes are left-anchored' '
77         git -c "pack.island=heads/(.*)" repack -adfi &&
78         is_delta_base $one $two
79 '
80
81 test_expect_success 'island regexes follow last-one-wins scheme' '
82         git \
83                 -c "pack.island=refs/heads/(.*)" \
84                 -c "pack.island=refs/heads/" \
85                 repack -adfi &&
86         is_delta_base $one $two
87 '
88
89 test_expect_success 'setup shared history' '
90         commit root shared root &&
91         commit one shared 1 root &&
92         commit two shared 12-long root
93 '
94
95 # We know that $two will be preferred as a base from $one,
96 # because we can transform it with a pure deletion.
97 #
98 # We also expect $root as a delta against $two by the "longest is base" rule.
99 test_expect_success 'vanilla delta goes between branches' '
100         git repack -adf &&
101         is_delta_base $one $two &&
102         is_delta_base $root $two
103 '
104
105 # Here we should allow $one to base itself on $root; even though
106 # they are in different islands, the objects in $root are in a superset
107 # of islands compared to those in $one.
108 #
109 # Similarly, $two can delta against $root by our rules. And unlike $one,
110 # in which we are just allowing it, the island rules actually put $root
111 # as a possible base for $two, which it would not otherwise be (due to the size
112 # sorting).
113 test_expect_success 'deltas allowed against superset islands' '
114         git -c "pack.island=refs/heads/(.*)" repack -adfi &&
115         is_delta_base $one $root &&
116         is_delta_base $two $root
117 '
118
119 # We are going to test the packfile order here, so we again have to make some
120 # assumptions. We assume that "$root", as part of our core "one", must come
121 # before "$two". This should be guaranteed by the island code. However, for
122 # this test to fail without islands, we are also assuming that it would not
123 # otherwise do so. This is true by the current write order, which will put
124 # commits (and their contents) before their parents.
125 test_expect_success 'island core places core objects first' '
126         cat >expect <<-EOF &&
127         $root
128         $two
129         EOF
130         git -c "pack.island=refs/heads/(.*)" \
131             -c "pack.islandcore=one" \
132             repack -adfi &&
133         git verify-pack -v .git/objects/pack/*.pack |
134         cut -d" " -f1 |
135         egrep "$root|$two" >actual &&
136         test_cmp expect actual
137 '
138
139 test_expect_success 'unmatched island core is not fatal' '
140         git -c "pack.islandcore=one" repack -adfi
141 '
142
143 test_done