org.spearce.jgit.test/tst/org/spearce/jgit/merge/SimpleMergeTest.java

   1 /*
   2  * Copyright (C) 2008, Robin Rosenberg
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or
   7  * without modification, are permitted provided that the following
   8  * conditions are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  *
  13  * - Redistributions in binary form must reproduce the above
  14  *   copyright notice, this list of conditions and the following
  15  *   disclaimer in the documentation and/or other materials provided
  16  *   with the distribution.
  17  *
  18  * - Neither the name of the Git Development Community nor the
  19  *   names of its contributors may be used to endorse or promote
  20  *   products derived from this software without specific prior
  21  *   written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  24  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  28  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  33  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37 package org.spearce.jgit.merge;
  38
  39 import java.io.ByteArrayInputStream;
  40 import java.io.IOException;
  41
  42 import org.spearce.jgit.dircache.DirCache;
  43 import org.spearce.jgit.dircache.DirCacheBuilder;
  44 import org.spearce.jgit.dircache.DirCacheEntry;
  45 import org.spearce.jgit.lib.Commit;
  46 import org.spearce.jgit.lib.Constants;
  47 import org.spearce.jgit.lib.FileMode;
  48 import org.spearce.jgit.lib.ObjectId;
  49 import org.spearce.jgit.lib.ObjectWriter;
  50 import org.spearce.jgit.lib.PersonIdent;
  51 import org.spearce.jgit.lib.RepositoryTestCase;
  52 import org.spearce.jgit.treewalk.TreeWalk;
  53
  54 public class SimpleMergeTest extends RepositoryTestCase {
  55
  56         public void testOurs() throws IOException {
  57                 Merger ourMerger = MergeStrategy.OURS.newMerger(db);
  58                 boolean merge = ourMerger.merge(new ObjectId[] { db.resolve("a"), db.resolve("c") });
  59                 assertTrue(merge);
  60                 assertEquals(db.mapTree("a").getId(), ourMerger.getResultTreeId());
  61         }
  62
  63         public void testTheirs() throws IOException {
  64                 Merger ourMerger = MergeStrategy.THEIRS.newMerger(db);
  65                 boolean merge = ourMerger.merge(new ObjectId[] { db.resolve("a"), db.resolve("c") });
  66                 assertTrue(merge);
  67                 assertEquals(db.mapTree("c").getId(), ourMerger.getResultTreeId());
  68         }
  69
  70         public void testTrivialTwoWay() throws IOException {
  71                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
  72                 boolean merge = ourMerger.merge(new ObjectId[] { db.resolve("a"), db.resolve("c") });
  73                 assertTrue(merge);
  74                 assertEquals("02ba32d3649e510002c21651936b7077aa75ffa9",ourMerger.getResultTreeId().name());
  75         }
  76
  77         public void testTrivialTwoWay_disjointhistories() throws IOException {
  78                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
  79                 boolean merge = ourMerger.merge(new ObjectId[] { db.resolve("a"), db.resolve("c~4") });
  80                 assertTrue(merge);
  81                 assertEquals("86265c33b19b2be71bdd7b8cb95823f2743d03a8",ourMerger.getResultTreeId().name());
  82         }
  83
  84         public void testTrivialTwoWay_ok() throws IOException {
  85                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
  86                 boolean merge = ourMerger.merge(new ObjectId[] { db.resolve("a^0^0^0"), db.resolve("a^0^0^1") });
  87                 assertTrue(merge);
  88                 assertEquals(db.mapTree("a^0^0").getId(), ourMerger.getResultTreeId());
  89         }
  90
  91         public void testTrivialTwoWay_conflict() throws IOException {
  92                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
  93                 boolean merge = ourMerger.merge(new ObjectId[] { db.resolve("f"), db.resolve("g") });
  94                 assertFalse(merge);
  95         }
  96
  97         public void testTrivialTwoWay_validSubtreeSort() throws Exception {
  98                 final DirCache treeB = DirCache.read(db);
  99                 final DirCache treeO = DirCache.read(db);
 100                 final DirCache treeT = DirCache.read(db);
 101                 {
 102                         final DirCacheBuilder b = treeB.builder();
 103                         final DirCacheBuilder o = treeO.builder();
 104                         final DirCacheBuilder t = treeT.builder();
 105
 106                         b.add(makeEntry("libelf-po/a", FileMode.REGULAR_FILE));
 107                         b.add(makeEntry("libelf/c", FileMode.REGULAR_FILE));
 108
 109                         o.add(makeEntry("Makefile", FileMode.REGULAR_FILE));
 110                         o.add(makeEntry("libelf-po/a", FileMode.REGULAR_FILE));
 111                         o.add(makeEntry("libelf/c", FileMode.REGULAR_FILE));
 112
 113                         t.add(makeEntry("libelf-po/a", FileMode.REGULAR_FILE));
 114                         t.add(makeEntry("libelf/c", FileMode.REGULAR_FILE, "blah"));
 115
 116                         b.finish();
 117                         o.finish();
 118                         t.finish();
 119                 }
 120
 121                 final ObjectWriter ow = new ObjectWriter(db);
 122                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 123                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 124                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 125
 126                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 127                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 128                 assertTrue(merge);
 129
 130                 final TreeWalk tw = new TreeWalk(db);
 131                 tw.setRecursive(true);
 132                 tw.reset(ourMerger.getResultTreeId());
 133
 134                 assertTrue(tw.next());
 135                 assertEquals("Makefile", tw.getPathString());
 136                 assertCorrectId(treeO, tw);
 137
 138                 assertTrue(tw.next());
 139                 assertEquals("libelf-po/a", tw.getPathString());
 140                 assertCorrectId(treeO, tw);
 141
 142                 assertTrue(tw.next());
 143                 assertEquals("libelf/c", tw.getPathString());
 144                 assertCorrectId(treeT, tw);
 145
 146                 assertFalse(tw.next());
 147         }
 148
 149         public void testTrivialTwoWay_concurrentSubtreeChange() throws Exception {
 150                 final DirCache treeB = DirCache.read(db);
 151                 final DirCache treeO = DirCache.read(db);
 152                 final DirCache treeT = DirCache.read(db);
 153                 {
 154                         final DirCacheBuilder b = treeB.builder();
 155                         final DirCacheBuilder o = treeO.builder();
 156                         final DirCacheBuilder t = treeT.builder();
 157
 158                         b.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 159                         b.add(makeEntry("d/t", FileMode.REGULAR_FILE));
 160
 161                         o.add(makeEntry("d/o", FileMode.REGULAR_FILE, "o !"));
 162                         o.add(makeEntry("d/t", FileMode.REGULAR_FILE));
 163
 164                         t.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 165                         t.add(makeEntry("d/t", FileMode.REGULAR_FILE, "t !"));
 166
 167                         b.finish();
 168                         o.finish();
 169                         t.finish();
 170                 }
 171
 172                 final ObjectWriter ow = new ObjectWriter(db);
 173                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 174                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 175                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 176
 177                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 178                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 179                 assertTrue(merge);
 180
 181                 final TreeWalk tw = new TreeWalk(db);
 182                 tw.setRecursive(true);
 183                 tw.reset(ourMerger.getResultTreeId());
 184
 185                 assertTrue(tw.next());
 186                 assertEquals("d/o", tw.getPathString());
 187                 assertCorrectId(treeO, tw);
 188
 189                 assertTrue(tw.next());
 190                 assertEquals("d/t", tw.getPathString());
 191                 assertCorrectId(treeT, tw);
 192
 193                 assertFalse(tw.next());
 194         }
 195
 196         public void testTrivialTwoWay_conflictSubtreeChange() throws Exception {
 197                 final DirCache treeB = DirCache.read(db);
 198                 final DirCache treeO = DirCache.read(db);
 199                 final DirCache treeT = DirCache.read(db);
 200                 {
 201                         final DirCacheBuilder b = treeB.builder();
 202                         final DirCacheBuilder o = treeO.builder();
 203                         final DirCacheBuilder t = treeT.builder();
 204
 205                         b.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 206                         b.add(makeEntry("d/t", FileMode.REGULAR_FILE));
 207
 208                         o.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 209                         o.add(makeEntry("d/t", FileMode.REGULAR_FILE, "o !"));
 210
 211                         t.add(makeEntry("d/o", FileMode.REGULAR_FILE, "t !"));
 212                         t.add(makeEntry("d/t", FileMode.REGULAR_FILE, "t !"));
 213
 214                         b.finish();
 215                         o.finish();
 216                         t.finish();
 217                 }
 218
 219                 final ObjectWriter ow = new ObjectWriter(db);
 220                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 221                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 222                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 223
 224                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 225                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 226                 assertFalse(merge);
 227         }
 228
 229         public void testTrivialTwoWay_leftDFconflict1() throws Exception {
 230                 final DirCache treeB = DirCache.read(db);
 231                 final DirCache treeO = DirCache.read(db);
 232                 final DirCache treeT = DirCache.read(db);
 233                 {
 234                         final DirCacheBuilder b = treeB.builder();
 235                         final DirCacheBuilder o = treeO.builder();
 236                         final DirCacheBuilder t = treeT.builder();
 237
 238                         b.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 239                         b.add(makeEntry("d/t", FileMode.REGULAR_FILE));
 240
 241                         o.add(makeEntry("d", FileMode.REGULAR_FILE));
 242
 243                         t.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 244                         t.add(makeEntry("d/t", FileMode.REGULAR_FILE, "t !"));
 245
 246                         b.finish();
 247                         o.finish();
 248                         t.finish();
 249                 }
 250
 251                 final ObjectWriter ow = new ObjectWriter(db);
 252                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 253                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 254                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 255
 256                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 257                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 258                 assertFalse(merge);
 259         }
 260
 261         public void testTrivialTwoWay_rightDFconflict1() throws Exception {
 262                 final DirCache treeB = DirCache.read(db);
 263                 final DirCache treeO = DirCache.read(db);
 264                 final DirCache treeT = DirCache.read(db);
 265                 {
 266                         final DirCacheBuilder b = treeB.builder();
 267                         final DirCacheBuilder o = treeO.builder();
 268                         final DirCacheBuilder t = treeT.builder();
 269
 270                         b.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 271                         b.add(makeEntry("d/t", FileMode.REGULAR_FILE));
 272
 273                         o.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 274                         o.add(makeEntry("d/t", FileMode.REGULAR_FILE, "o !"));
 275
 276                         t.add(makeEntry("d", FileMode.REGULAR_FILE));
 277
 278                         b.finish();
 279                         o.finish();
 280                         t.finish();
 281                 }
 282
 283                 final ObjectWriter ow = new ObjectWriter(db);
 284                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 285                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 286                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 287
 288                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 289                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 290                 assertFalse(merge);
 291         }
 292
 293         public void testTrivialTwoWay_leftDFconflict2() throws Exception {
 294                 final DirCache treeB = DirCache.read(db);
 295                 final DirCache treeO = DirCache.read(db);
 296                 final DirCache treeT = DirCache.read(db);
 297                 {
 298                         final DirCacheBuilder b = treeB.builder();
 299                         final DirCacheBuilder o = treeO.builder();
 300                         final DirCacheBuilder t = treeT.builder();
 301
 302                         b.add(makeEntry("d", FileMode.REGULAR_FILE));
 303
 304                         o.add(makeEntry("d", FileMode.REGULAR_FILE, "o !"));
 305
 306                         t.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 307
 308                         b.finish();
 309                         o.finish();
 310                         t.finish();
 311                 }
 312
 313                 final ObjectWriter ow = new ObjectWriter(db);
 314                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 315                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 316                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 317
 318                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 319                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 320                 assertFalse(merge);
 321         }
 322
 323         public void testTrivialTwoWay_rightDFconflict2() throws Exception {
 324                 final DirCache treeB = DirCache.read(db);
 325                 final DirCache treeO = DirCache.read(db);
 326                 final DirCache treeT = DirCache.read(db);
 327                 {
 328                         final DirCacheBuilder b = treeB.builder();
 329                         final DirCacheBuilder o = treeO.builder();
 330                         final DirCacheBuilder t = treeT.builder();
 331
 332                         b.add(makeEntry("d", FileMode.REGULAR_FILE));
 333
 334                         o.add(makeEntry("d/o", FileMode.REGULAR_FILE));
 335
 336                         t.add(makeEntry("d", FileMode.REGULAR_FILE, "t !"));
 337
 338                         b.finish();
 339                         o.finish();
 340                         t.finish();
 341                 }
 342
 343                 final ObjectWriter ow = new ObjectWriter(db);
 344                 final ObjectId b = commit(ow, treeB, new ObjectId[] {});
 345                 final ObjectId o = commit(ow, treeO, new ObjectId[] { b });
 346                 final ObjectId t = commit(ow, treeT, new ObjectId[] { b });
 347
 348                 Merger ourMerger = MergeStrategy.SIMPLE_TWO_WAY_IN_CORE.newMerger(db);
 349                 boolean merge = ourMerger.merge(new ObjectId[] { o, t });
 350                 assertFalse(merge);
 351         }
 352
 353         private void assertCorrectId(final DirCache treeT, final TreeWalk tw) {
 354                 assertEquals(treeT.getEntry(tw.getPathString()).getObjectId(), tw
 355                                 .getObjectId(0));
 356         }
 357
 358         private ObjectId commit(final ObjectWriter ow, final DirCache treeB,
 359                         final ObjectId[] parentIds) throws Exception {
 360                 final Commit c = new Commit(db);
 361                 c.setTreeId(treeB.writeTree(ow));
 362                 c.setAuthor(new PersonIdent("A U Thor", "a.u.thor", 1L, 0));
 363                 c.setCommitter(c.getAuthor());
 364                 c.setParentIds(parentIds);
 365                 c.setMessage("Tree " + c.getTreeId().name());
 366                 return ow.writeCommit(c);
 367         }
 368
 369         private DirCacheEntry makeEntry(final String path, final FileMode mode)
 370                         throws Exception {
 371                 return makeEntry(path, mode, path);
 372         }
 373
 374         private DirCacheEntry makeEntry(final String path, final FileMode mode,
 375                         final String content) throws Exception {
 376                 final DirCacheEntry ent = new DirCacheEntry(path);
 377                 ent.setFileMode(mode);
 378                 final byte[] contentBytes = Constants.encode(content);
 379                 ent.setObjectId(new ObjectWriter(db).computeBlobSha1(
 380                                 contentBytes.length, new ByteArrayInputStream(contentBytes)));
 381                 return ent;
 382         }
 383 }