t/t3421-rebase-topology-linear.sh

   1 #!/bin/sh
   2
   3 test_description='basic rebase topology tests'
   4 . ./test-lib.sh
   5 . "$TEST_DIRECTORY"/lib-rebase.sh
   6
   7 # a---b---c
   8 #      \
   9 #       d---e
  10 test_expect_success 'setup' '
  11         test_commit a &&
  12         test_commit b &&
  13         test_commit c &&
  14         git checkout b &&
  15         test_commit d &&
  16         test_commit e
  17 '
  18
  19 test_run_rebase () {
  20         result=$1
  21         shift
  22         test_expect_$result "simple rebase $*" "
  23                 reset_rebase &&
  24                 git rebase $* c e &&
  25                 test_cmp_rev c HEAD~2 &&
  26                 test_linear_range 'd e' c..
  27         "
  28 }
  29 test_run_rebase success ''
  30 test_run_rebase success -m
  31 test_run_rebase success -i
  32 test_run_rebase success -p
  33
  34 test_run_rebase () {
  35         result=$1
  36         shift
  37         test_expect_$result "rebase $* is no-op if upstream is an ancestor" "
  38                 reset_rebase &&
  39                 git rebase $* b e &&
  40                 test_cmp_rev e HEAD
  41         "
  42 }
  43 test_run_rebase success ''
  44 test_run_rebase success -m
  45 test_run_rebase success -i
  46 test_run_rebase success -p
  47
  48 test_run_rebase () {
  49         result=$1
  50         shift
  51         test_expect_$result "rebase $* -f rewrites even if upstream is an ancestor" "
  52                 reset_rebase &&
  53                 git rebase $* -f b e &&
  54                 ! test_cmp_rev e HEAD &&
  55                 test_cmp_rev b HEAD~2 &&
  56                 test_linear_range 'd e' b..
  57         "
  58 }
  59 test_run_rebase success ''
  60 test_run_rebase success -m
  61 test_run_rebase success -i
  62 test_run_rebase failure -p
  63
  64 test_run_rebase () {
  65         result=$1
  66         shift
  67         test_expect_$result "rebase $* fast-forwards from ancestor of upstream" "
  68                 reset_rebase &&
  69                 git rebase $* e b &&
  70                 test_cmp_rev e HEAD
  71         "
  72 }
  73 test_run_rebase success ''
  74 test_run_rebase success -m
  75 test_run_rebase success -i
  76 test_run_rebase success -p
  77
  78 #       f
  79 #      /
  80 # a---b---c---g---h
  81 #      \
  82 #       d---gp--i
  83 #
  84 # gp = cherry-picked g
  85 # h = reverted g
  86 #
  87 # Reverted patches are there for tests to be able to check if a commit
  88 # that introduced the same change as another commit is
  89 # dropped. Without reverted commits, we could get false positives
  90 # because applying the patch succeeds, but simply results in no
  91 # changes.
  92 test_expect_success 'setup of linear history for range selection tests' '
  93         git checkout c &&
  94         test_commit g &&
  95         revert h g &&
  96         git checkout d &&
  97         cherry_pick gp g &&
  98         test_commit i &&
  99         git checkout b &&
 100         test_commit f
 101 '
 102
 103 test_run_rebase () {
 104         result=$1
 105         shift
 106         test_expect_$result "rebase $* drops patches in upstream" "
 107                 reset_rebase &&
 108                 git rebase $* h i &&
 109                 test_cmp_rev h HEAD~2 &&
 110                 test_linear_range 'd i' h..
 111         "
 112 }
 113 test_run_rebase success ''
 114 test_run_rebase failure -m
 115 test_run_rebase success -i
 116 test_run_rebase success -p
 117
 118 test_run_rebase () {
 119         result=$1
 120         shift
 121         test_expect_$result "rebase $* can drop last patch if in upstream" "
 122                 reset_rebase &&
 123                 git rebase $* h gp &&
 124                 test_cmp_rev h HEAD^ &&
 125                 test_linear_range 'd' h..
 126         "
 127 }
 128 test_run_rebase success ''
 129 test_run_rebase failure -m
 130 test_run_rebase success -i
 131 test_run_rebase success -p
 132
 133 test_run_rebase () {
 134         result=$1
 135         shift
 136         test_expect_$result "rebase $* --onto drops patches in upstream" "
 137                 reset_rebase &&
 138                 git rebase $* --onto f h i &&
 139                 test_cmp_rev f HEAD~2 &&
 140                 test_linear_range 'd i' f..
 141         "
 142 }
 143 test_run_rebase success ''
 144 test_run_rebase failure -m
 145 test_run_rebase success -i
 146 test_run_rebase success -p
 147
 148 test_run_rebase () {
 149         result=$1
 150         shift
 151         test_expect_$result "rebase $* --onto does not drop patches in onto" "
 152                 reset_rebase &&
 153                 git rebase $* --onto h f i &&
 154                 test_cmp_rev h HEAD~3 &&
 155                 test_linear_range 'd gp i' h..
 156         "
 157 }
 158 test_run_rebase success ''
 159 test_run_rebase success -m
 160 test_run_rebase success -i
 161 test_run_rebase success -p
 162
 163 # a---b---c---j!
 164 #      \
 165 #       d---k!--l
 166 #
 167 # ! = empty
 168 test_expect_success 'setup of linear history for empty commit tests' '
 169         git checkout c &&
 170         make_empty j &&
 171         git checkout d &&
 172         make_empty k &&
 173         test_commit l
 174 '
 175
 176 test_run_rebase () {
 177         result=$1
 178         shift
 179         test_expect_$result "rebase $* drops empty commit" "
 180                 reset_rebase &&
 181                 git rebase $* c l &&
 182                 test_cmp_rev c HEAD~2 &&
 183                 test_linear_range 'd l' c..
 184         "
 185 }
 186 test_run_rebase success ''
 187 test_run_rebase success -m
 188 test_run_rebase success -i
 189 test_run_rebase success -p
 190
 191 test_run_rebase () {
 192         result=$1
 193         shift
 194         test_expect_$result "rebase $* --keep-empty" "
 195                 reset_rebase &&
 196                 git rebase $* --keep-empty c l &&
 197                 test_cmp_rev c HEAD~3 &&
 198                 test_linear_range 'd k l' c..
 199         "
 200 }
 201 test_run_rebase success ''
 202 test_run_rebase success -m
 203 test_run_rebase success -i
 204 test_run_rebase failure -p
 205
 206 test_run_rebase () {
 207         result=$1
 208         shift
 209         test_expect_$result "rebase $* --keep-empty keeps empty even if already in upstream" "
 210                 reset_rebase &&
 211                 git rebase $* --keep-empty j l &&
 212                 test_cmp_rev j HEAD~3 &&
 213                 test_linear_range 'd k l' j..
 214         "
 215 }
 216 test_run_rebase success ''
 217 test_run_rebase success -m
 218 test_run_rebase success -i
 219 test_run_rebase failure -p
 220 test_run_rebase success --rebase-merges
 221
 222 #       m
 223 #      /
 224 # a---b---c---g
 225 #
 226 # x---y---bp
 227 #
 228 # bp = cherry-picked b
 229 # m = reverted b
 230 #
 231 # Reverted patches are there for tests to be able to check if a commit
 232 # that introduced the same change as another commit is
 233 # dropped. Without reverted commits, we could get false positives
 234 # because applying the patch succeeds, but simply results in no
 235 # changes.
 236 test_expect_success 'setup of linear history for test involving root' '
 237         git checkout b &&
 238         revert m b &&
 239         git checkout --orphan disjoint &&
 240         git rm -rf . &&
 241         test_commit x &&
 242         test_commit y &&
 243         cherry_pick bp b
 244 '
 245
 246 test_run_rebase () {
 247         result=$1
 248         shift
 249         test_expect_$result "rebase $* --onto --root" "
 250                 reset_rebase &&
 251                 git rebase $* --onto c --root y &&
 252                 test_cmp_rev c HEAD~2 &&
 253                 test_linear_range 'x y' c..
 254         "
 255 }
 256 test_run_rebase success ''
 257 test_run_rebase success -m
 258 test_run_rebase success -i
 259 test_run_rebase success -p
 260
 261 test_run_rebase () {
 262         result=$1
 263         shift
 264         test_expect_$result "rebase $* without --onto --root with disjoint history" "
 265                 reset_rebase &&
 266                 git rebase $* c y &&
 267                 test_cmp_rev c HEAD~2 &&
 268                 test_linear_range 'x y' c..
 269         "
 270 }
 271 test_run_rebase success ''
 272 test_run_rebase success -m
 273 test_run_rebase success -i
 274 test_run_rebase failure -p
 275
 276 test_run_rebase () {
 277         result=$1
 278         shift
 279         test_expect_$result "rebase $* --onto --root drops patch in onto" "
 280                 reset_rebase &&
 281                 git rebase $* --onto m --root bp &&
 282                 test_cmp_rev m HEAD~2 &&
 283                 test_linear_range 'x y' m..
 284         "
 285 }
 286 test_run_rebase success ''
 287 test_run_rebase failure -m
 288 test_run_rebase success -i
 289 test_run_rebase success -p
 290
 291 test_run_rebase () {
 292         result=$1
 293         shift
 294         test_expect_$result "rebase $* --onto --root with merge-base does not go to root" "
 295                 reset_rebase &&
 296                 git rebase $* --onto m --root g &&
 297                 test_cmp_rev m HEAD~2 &&
 298                 test_linear_range 'c g' m..
 299         "
 300 }
 301
 302 test_run_rebase success ''
 303 test_run_rebase success -m
 304 test_run_rebase success -i
 305 test_run_rebase failure -p
 306
 307 test_run_rebase () {
 308         result=$1
 309         shift
 310         test_expect_$result "rebase $* without --onto --root with disjoint history drops patch in onto" "
 311                 reset_rebase &&
 312                 git rebase $* m bp &&
 313                 test_cmp_rev m HEAD~2 &&
 314                 test_linear_range 'x y' m..
 315         "
 316 }
 317 test_run_rebase success ''
 318 test_run_rebase failure -m
 319 test_run_rebase success -i
 320 test_run_rebase failure -p
 321
 322 test_run_rebase () {
 323         result=$1
 324         shift
 325         test_expect_$result "rebase $* --root on linear history is a no-op" "
 326                 reset_rebase &&
 327                 git rebase $* --root c &&
 328                 test_cmp_rev c HEAD
 329         "
 330 }
 331 test_run_rebase success ''
 332 test_run_rebase success -m
 333 test_run_rebase success -i
 334 test_run_rebase failure -p
 335
 336 test_run_rebase () {
 337         result=$1
 338         shift
 339         test_expect_$result "rebase $* -f --root on linear history causes re-write" "
 340                 reset_rebase &&
 341                 git rebase $* -f --root c &&
 342                 ! test_cmp_rev a HEAD~2 &&
 343                 test_linear_range 'a b c' HEAD
 344         "
 345 }
 346 test_run_rebase success ''
 347 test_run_rebase success -m
 348 test_run_rebase success -i
 349 test_run_rebase success -p
 350
 351 test_done