Merge branch 'js/maint-daemon'
[git] / t / t6030-bisect-porcelain.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2007 Christian Couder
4 #
5 test_description='Tests git-bisect functionality'
6
7 exec </dev/null
8
9 . ./test-lib.sh
10
11 add_line_into_file()
12 {
13     _line=$1
14     _file=$2
15
16     if [ -f "$_file" ]; then
17         echo "$_line" >> $_file || return $?
18         MSG="Add <$_line> into <$_file>."
19     else
20         echo "$_line" > $_file || return $?
21         git add $_file || return $?
22         MSG="Create file <$_file> with <$_line> inside."
23     fi
24
25     test_tick
26     git-commit --quiet -m "$MSG" $_file
27 }
28
29 HASH1=
30 HASH2=
31 HASH3=
32 HASH4=
33
34 test_expect_success 'set up basic repo with 1 file (hello) and 4 commits' '
35      add_line_into_file "1: Hello World" hello &&
36      HASH1=$(git rev-parse --verify HEAD) &&
37      add_line_into_file "2: A new day for git" hello &&
38      HASH2=$(git rev-parse --verify HEAD) &&
39      add_line_into_file "3: Another new day for git" hello &&
40      HASH3=$(git rev-parse --verify HEAD) &&
41      add_line_into_file "4: Ciao for now" hello &&
42      HASH4=$(git rev-parse --verify HEAD)
43 '
44
45 test_expect_success 'bisect starts with only one bad' '
46         git bisect reset &&
47         git bisect start &&
48         git bisect bad $HASH4 &&
49         git bisect next
50 '
51
52 test_expect_success 'bisect does not start with only one good' '
53         git bisect reset &&
54         git bisect start &&
55         git bisect good $HASH1 || return 1
56
57         if git bisect next
58         then
59                 echo Oops, should have failed.
60                 false
61         else
62                 :
63         fi
64 '
65
66 test_expect_success 'bisect start with one bad and good' '
67         git bisect reset &&
68         git bisect start &&
69         git bisect good $HASH1 &&
70         git bisect bad $HASH4 &&
71         git bisect next
72 '
73
74 test_expect_success 'bisect reset: back in the master branch' '
75         git bisect reset &&
76         echo "* master" > branch.expect &&
77         git branch > branch.output &&
78         cmp branch.expect branch.output
79 '
80
81 test_expect_success 'bisect reset: back in another branch' '
82         git checkout -b other &&
83         git bisect start &&
84         git bisect good $HASH1 &&
85         git bisect bad $HASH3 &&
86         git bisect reset &&
87         echo "  master" > branch.expect &&
88         echo "* other" >> branch.expect &&
89         git branch > branch.output &&
90         cmp branch.expect branch.output
91 '
92
93 test_expect_success 'bisect reset when not bisecting' '
94         git bisect reset &&
95         git branch > branch.output &&
96         cmp branch.expect branch.output
97 '
98
99 test_expect_success 'bisect reset removes packed refs' '
100         git bisect reset &&
101         git bisect start &&
102         git bisect good $HASH1 &&
103         git bisect bad $HASH3 &&
104         git pack-refs --all --prune &&
105         git bisect next &&
106         git bisect reset &&
107         test -z "$(git for-each-ref "refs/bisect/*")" &&
108         test -z "$(git for-each-ref "refs/heads/bisect")"
109 '
110
111 # $HASH1 is good, $HASH4 is bad, we skip $HASH3
112 # but $HASH2 is bad,
113 # so we should find $HASH2 as the first bad commit
114 test_expect_success 'bisect skip: successfull result' '
115         git bisect reset &&
116         git bisect start $HASH4 $HASH1 &&
117         git bisect skip &&
118         git bisect bad > my_bisect_log.txt &&
119         grep "$HASH2 is first bad commit" my_bisect_log.txt &&
120         git bisect reset
121 '
122
123 # $HASH1 is good, $HASH4 is bad, we skip $HASH3 and $HASH2
124 # so we should not be able to tell the first bad commit
125 # among $HASH2, $HASH3 and $HASH4
126 test_expect_success 'bisect skip: cannot tell between 3 commits' '
127         git bisect start $HASH4 $HASH1 &&
128         git bisect skip || return 1
129
130         if git bisect skip > my_bisect_log.txt
131         then
132                 echo Oops, should have failed.
133                 false
134         else
135                 test $? -eq 2 &&
136                 grep "first bad commit could be any of" my_bisect_log.txt &&
137                 ! grep $HASH1 my_bisect_log.txt &&
138                 grep $HASH2 my_bisect_log.txt &&
139                 grep $HASH3 my_bisect_log.txt &&
140                 grep $HASH4 my_bisect_log.txt &&
141                 git bisect reset
142         fi
143 '
144
145 # $HASH1 is good, $HASH4 is bad, we skip $HASH3
146 # but $HASH2 is good,
147 # so we should not be able to tell the first bad commit
148 # among $HASH3 and $HASH4
149 test_expect_success 'bisect skip: cannot tell between 2 commits' '
150         git bisect start $HASH4 $HASH1 &&
151         git bisect skip || return 1
152
153         if git bisect good > my_bisect_log.txt
154         then
155                 echo Oops, should have failed.
156                 false
157         else
158                 test $? -eq 2 &&
159                 grep "first bad commit could be any of" my_bisect_log.txt &&
160                 ! grep $HASH1 my_bisect_log.txt &&
161                 ! grep $HASH2 my_bisect_log.txt &&
162                 grep $HASH3 my_bisect_log.txt &&
163                 grep $HASH4 my_bisect_log.txt &&
164                 git bisect reset
165         fi
166 '
167
168 # We want to automatically find the commit that
169 # introduced "Another" into hello.
170 test_expect_success \
171     '"git bisect run" simple case' \
172     'echo "#"\!"/bin/sh" > test_script.sh &&
173      echo "grep Another hello > /dev/null" >> test_script.sh &&
174      echo "test \$? -ne 0" >> test_script.sh &&
175      chmod +x test_script.sh &&
176      git bisect start &&
177      git bisect good $HASH1 &&
178      git bisect bad $HASH4 &&
179      git bisect run ./test_script.sh > my_bisect_log.txt &&
180      grep "$HASH3 is first bad commit" my_bisect_log.txt &&
181      git bisect reset'
182
183 # We want to automatically find the commit that
184 # introduced "Ciao" into hello.
185 test_expect_success \
186     '"git bisect run" with more complex "git bisect start"' \
187     'echo "#"\!"/bin/sh" > test_script.sh &&
188      echo "grep Ciao hello > /dev/null" >> test_script.sh &&
189      echo "test \$? -ne 0" >> test_script.sh &&
190      chmod +x test_script.sh &&
191      git bisect start $HASH4 $HASH1 &&
192      git bisect run ./test_script.sh > my_bisect_log.txt &&
193      grep "$HASH4 is first bad commit" my_bisect_log.txt &&
194      git bisect reset'
195
196 # $HASH1 is good, $HASH5 is bad, we skip $HASH3
197 # but $HASH4 is good,
198 # so we should find $HASH5 as the first bad commit
199 HASH5=
200 test_expect_success 'bisect skip: add line and then a new test' '
201         add_line_into_file "5: Another new line." hello &&
202         HASH5=$(git rev-parse --verify HEAD) &&
203         git bisect start $HASH5 $HASH1 &&
204         git bisect skip &&
205         git bisect good > my_bisect_log.txt &&
206         grep "$HASH5 is first bad commit" my_bisect_log.txt &&
207         git bisect log > log_to_replay.txt &&
208         git bisect reset
209 '
210
211 test_expect_success 'bisect skip and bisect replay' '
212         git bisect replay log_to_replay.txt > my_bisect_log.txt &&
213         grep "$HASH5 is first bad commit" my_bisect_log.txt &&
214         git bisect reset
215 '
216
217 HASH6=
218 test_expect_success 'bisect run & skip: cannot tell between 2' '
219         add_line_into_file "6: Yet a line." hello &&
220         HASH6=$(git rev-parse --verify HEAD) &&
221         echo "#"\!"/bin/sh" > test_script.sh &&
222         echo "tail -1 hello | grep Ciao > /dev/null && exit 125" >> test_script.sh &&
223         echo "grep line hello > /dev/null" >> test_script.sh &&
224         echo "test \$? -ne 0" >> test_script.sh &&
225         chmod +x test_script.sh &&
226         git bisect start $HASH6 $HASH1 &&
227         if git bisect run ./test_script.sh > my_bisect_log.txt
228         then
229                 echo Oops, should have failed.
230                 false
231         else
232                 test $? -eq 2 &&
233                 grep "first bad commit could be any of" my_bisect_log.txt &&
234                 ! grep $HASH3 my_bisect_log.txt &&
235                 ! grep $HASH6 my_bisect_log.txt &&
236                 grep $HASH4 my_bisect_log.txt &&
237                 grep $HASH5 my_bisect_log.txt
238         fi
239 '
240
241 HASH7=
242 test_expect_success 'bisect run & skip: find first bad' '
243         git bisect reset &&
244         add_line_into_file "7: Should be the last line." hello &&
245         HASH7=$(git rev-parse --verify HEAD) &&
246         echo "#"\!"/bin/sh" > test_script.sh &&
247         echo "tail -1 hello | grep Ciao > /dev/null && exit 125" >> test_script.sh &&
248         echo "tail -1 hello | grep day > /dev/null && exit 125" >> test_script.sh &&
249         echo "grep Yet hello > /dev/null" >> test_script.sh &&
250         echo "test \$? -ne 0" >> test_script.sh &&
251         chmod +x test_script.sh &&
252         git bisect start $HASH7 $HASH1 &&
253         git bisect run ./test_script.sh > my_bisect_log.txt &&
254         grep "$HASH6 is first bad commit" my_bisect_log.txt
255 '
256
257 test_expect_success 'bisect starting with a detached HEAD' '
258
259         git bisect reset &&
260         git checkout master^ &&
261         HEAD=$(git rev-parse --verify HEAD) &&
262         git bisect start &&
263         test $HEAD = $(cat .git/BISECT_START) &&
264         git bisect reset &&
265         test $HEAD = $(git rev-parse --verify HEAD)
266
267 '
268
269 #
270 #
271 test_done