org.spearce.jgit.test/tst/org/spearce/jgit/patch/FileHeaderTest.java

   1 /*
   2  * Copyright (C) 2008, Google Inc.
   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.patch;
  38
  39 import junit.framework.TestCase;
  40
  41 import org.spearce.jgit.lib.Constants;
  42 import org.spearce.jgit.lib.FileMode;
  43 import org.spearce.jgit.lib.ObjectId;
  44
  45 public class FileHeaderTest extends TestCase {
  46         public void testParseGitFileName_Empty() {
  47                 final FileHeader fh = data("");
  48                 assertEquals(-1, fh.parseGitFileName(0, fh.buf.length));
  49                 assertNotNull(fh.getHunks());
  50                 assertTrue(fh.getHunks().isEmpty());
  51                 assertFalse(fh.hasMetaDataChanges());
  52         }
  53
  54         public void testParseGitFileName_NoLF() {
  55                 final FileHeader fh = data("a/ b/");
  56                 assertEquals(-1, fh.parseGitFileName(0, fh.buf.length));
  57         }
  58
  59         public void testParseGitFileName_NoSecondLine() {
  60                 final FileHeader fh = data("\n");
  61                 assertEquals(-1, fh.parseGitFileName(0, fh.buf.length));
  62         }
  63
  64         public void testParseGitFileName_EmptyHeader() {
  65                 final FileHeader fh = data("\n\n");
  66                 assertEquals(1, fh.parseGitFileName(0, fh.buf.length));
  67         }
  68
  69         public void testParseGitFileName_Foo() {
  70                 final String name = "foo";
  71                 final FileHeader fh = header(name);
  72                 assertEquals(gitLine(name).length(), fh.parseGitFileName(0,
  73                                 fh.buf.length));
  74                 assertEquals(name, fh.getOldName());
  75                 assertSame(fh.getOldName(), fh.getNewName());
  76                 assertFalse(fh.hasMetaDataChanges());
  77         }
  78
  79         public void testParseGitFileName_FailFooBar() {
  80                 final FileHeader fh = data("a/foo b/bar\n-");
  81                 assertTrue(fh.parseGitFileName(0, fh.buf.length) > 0);
  82                 assertNull(fh.getOldName());
  83                 assertNull(fh.getNewName());
  84                 assertFalse(fh.hasMetaDataChanges());
  85         }
  86
  87         public void testParseGitFileName_FooSpBar() {
  88                 final String name = "foo bar";
  89                 final FileHeader fh = header(name);
  90                 assertEquals(gitLine(name).length(), fh.parseGitFileName(0,
  91                                 fh.buf.length));
  92                 assertEquals(name, fh.getOldName());
  93                 assertSame(fh.getOldName(), fh.getNewName());
  94                 assertFalse(fh.hasMetaDataChanges());
  95         }
  96
  97         public void testParseGitFileName_DqFooTabBar() {
  98                 final String name = "foo\tbar";
  99                 final String dqName = "foo\\tbar";
 100                 final FileHeader fh = dqHeader(dqName);
 101                 assertEquals(dqGitLine(dqName).length(), fh.parseGitFileName(0,
 102                                 fh.buf.length));
 103                 assertEquals(name, fh.getOldName());
 104                 assertSame(fh.getOldName(), fh.getNewName());
 105                 assertFalse(fh.hasMetaDataChanges());
 106         }
 107
 108         public void testParseGitFileName_DqFooSpLfNulBar() {
 109                 final String name = "foo \n\0bar";
 110                 final String dqName = "foo \\n\\0bar";
 111                 final FileHeader fh = dqHeader(dqName);
 112                 assertEquals(dqGitLine(dqName).length(), fh.parseGitFileName(0,
 113                                 fh.buf.length));
 114                 assertEquals(name, fh.getOldName());
 115                 assertSame(fh.getOldName(), fh.getNewName());
 116                 assertFalse(fh.hasMetaDataChanges());
 117         }
 118
 119         public void testParseGitFileName_SrcFooC() {
 120                 final String name = "src/foo/bar/argh/code.c";
 121                 final FileHeader fh = header(name);
 122                 assertEquals(gitLine(name).length(), fh.parseGitFileName(0,
 123                                 fh.buf.length));
 124                 assertEquals(name, fh.getOldName());
 125                 assertSame(fh.getOldName(), fh.getNewName());
 126                 assertFalse(fh.hasMetaDataChanges());
 127         }
 128
 129         public void testParseGitFileName_SrcFooCNonStandardPrefix() {
 130                 final String name = "src/foo/bar/argh/code.c";
 131                 final String header = "project-v-1.0/" + name + " mydev/" + name + "\n";
 132                 final FileHeader fh = data(header + "-");
 133                 assertEquals(header.length(), fh.parseGitFileName(0, fh.buf.length));
 134                 assertEquals(name, fh.getOldName());
 135                 assertSame(fh.getOldName(), fh.getNewName());
 136                 assertFalse(fh.hasMetaDataChanges());
 137         }
 138
 139         public void testParseUnicodeName_NewFile() {
 140                 final FileHeader fh = data("diff --git \"a/\\303\\205ngstr\\303\\266m\" \"b/\\303\\205ngstr\\303\\266m\"\n"
 141                                 + "new file mode 100644\n"
 142                                 + "index 0000000..7898192\n"
 143                                 + "--- /dev/null\n"
 144                                 + "+++ \"b/\\303\\205ngstr\\303\\266m\"\n"
 145                                 + "@@ -0,0 +1 @@\n" + "+a\n");
 146                 assertParse(fh);
 147
 148                 assertEquals("/dev/null", fh.getOldName());
 149                 assertSame(FileHeader.DEV_NULL, fh.getOldName());
 150                 assertEquals("\u00c5ngstr\u00f6m", fh.getNewName());
 151
 152                 assertSame(FileHeader.ChangeType.ADD, fh.getChangeType());
 153                 assertSame(FileHeader.PatchType.UNIFIED, fh.getPatchType());
 154                 assertTrue(fh.hasMetaDataChanges());
 155
 156                 assertSame(FileMode.MISSING, fh.getOldMode());
 157                 assertSame(FileMode.REGULAR_FILE, fh.getNewMode());
 158
 159                 assertEquals("0000000", fh.getOldId().name());
 160                 assertEquals("7898192", fh.getNewId().name());
 161                 assertEquals(0, fh.getScore());
 162         }
 163
 164         public void testParseUnicodeName_DeleteFile() {
 165                 final FileHeader fh = data("diff --git \"a/\\303\\205ngstr\\303\\266m\" \"b/\\303\\205ngstr\\303\\266m\"\n"
 166                                 + "deleted file mode 100644\n"
 167                                 + "index 7898192..0000000\n"
 168                                 + "--- \"a/\\303\\205ngstr\\303\\266m\"\n"
 169                                 + "+++ /dev/null\n"
 170                                 + "@@ -1 +0,0 @@\n" + "-a\n");
 171                 assertParse(fh);
 172
 173                 assertEquals("\u00c5ngstr\u00f6m", fh.getOldName());
 174                 assertEquals("/dev/null", fh.getNewName());
 175                 assertSame(FileHeader.DEV_NULL, fh.getNewName());
 176
 177                 assertSame(FileHeader.ChangeType.DELETE, fh.getChangeType());
 178                 assertSame(FileHeader.PatchType.UNIFIED, fh.getPatchType());
 179                 assertTrue(fh.hasMetaDataChanges());
 180
 181                 assertSame(FileMode.REGULAR_FILE, fh.getOldMode());
 182                 assertSame(FileMode.MISSING, fh.getNewMode());
 183
 184                 assertEquals("7898192", fh.getOldId().name());
 185                 assertEquals("0000000", fh.getNewId().name());
 186                 assertEquals(0, fh.getScore());
 187         }
 188
 189         public void testParseModeChange() {
 190                 final FileHeader fh = data("diff --git a/a b b/a b\n"
 191                                 + "old mode 100644\n" + "new mode 100755\n");
 192                 assertParse(fh);
 193                 assertEquals("a b", fh.getOldName());
 194                 assertEquals("a b", fh.getNewName());
 195
 196                 assertSame(FileHeader.ChangeType.MODIFY, fh.getChangeType());
 197                 assertSame(FileHeader.PatchType.UNIFIED, fh.getPatchType());
 198                 assertTrue(fh.hasMetaDataChanges());
 199
 200                 assertNull(fh.getOldId());
 201                 assertNull(fh.getNewId());
 202
 203                 assertSame(FileMode.REGULAR_FILE, fh.getOldMode());
 204                 assertSame(FileMode.EXECUTABLE_FILE, fh.getNewMode());
 205                 assertEquals(0, fh.getScore());
 206         }
 207
 208         public void testParseRename100_NewStyle() {
 209                 final FileHeader fh = data("diff --git a/a b/ c/\\303\\205ngstr\\303\\266m\n"
 210                                 + "similarity index 100%\n"
 211                                 + "rename from a\n"
 212                                 + "rename to \" c/\\303\\205ngstr\\303\\266m\"\n");
 213                 int ptr = fh.parseGitFileName(0, fh.buf.length);
 214                 assertTrue(ptr > 0);
 215                 assertNull(fh.getOldName()); // can't parse names on a rename
 216                 assertNull(fh.getNewName());
 217
 218                 ptr = fh.parseGitHeaders(ptr, fh.buf.length);
 219                 assertTrue(ptr > 0);
 220
 221                 assertEquals("a", fh.getOldName());
 222                 assertEquals(" c/\u00c5ngstr\u00f6m", fh.getNewName());
 223
 224                 assertSame(FileHeader.ChangeType.RENAME, fh.getChangeType());
 225                 assertSame(FileHeader.PatchType.UNIFIED, fh.getPatchType());
 226                 assertTrue(fh.hasMetaDataChanges());
 227
 228                 assertNull(fh.getOldId());
 229                 assertNull(fh.getNewId());
 230
 231                 assertNull(fh.getOldMode());
 232                 assertNull(fh.getNewMode());
 233
 234                 assertEquals(100, fh.getScore());
 235         }
 236
 237         public void testParseRename100_OldStyle() {
 238                 final FileHeader fh = data("diff --git a/a b/ c/\\303\\205ngstr\\303\\266m\n"
 239                                 + "similarity index 100%\n"
 240                                 + "rename old a\n"
 241                                 + "rename new \" c/\\303\\205ngstr\\303\\266m\"\n");
 242                 int ptr = fh.parseGitFileName(0, fh.buf.length);
 243                 assertTrue(ptr > 0);
 244                 assertNull(fh.getOldName()); // can't parse names on a rename
 245                 assertNull(fh.getNewName());
 246
 247                 ptr = fh.parseGitHeaders(ptr, fh.buf.length);
 248                 assertTrue(ptr > 0);
 249
 250                 assertEquals("a", fh.getOldName());
 251                 assertEquals(" c/\u00c5ngstr\u00f6m", fh.getNewName());
 252
 253                 assertSame(FileHeader.ChangeType.RENAME, fh.getChangeType());
 254                 assertSame(FileHeader.PatchType.UNIFIED, fh.getPatchType());
 255                 assertTrue(fh.hasMetaDataChanges());
 256
 257                 assertNull(fh.getOldId());
 258                 assertNull(fh.getNewId());
 259
 260                 assertNull(fh.getOldMode());
 261                 assertNull(fh.getNewMode());
 262
 263                 assertEquals(100, fh.getScore());
 264         }
 265
 266         public void testParseCopy100() {
 267                 final FileHeader fh = data("diff --git a/a b/ c/\\303\\205ngstr\\303\\266m\n"
 268                                 + "similarity index 100%\n"
 269                                 + "copy from a\n"
 270                                 + "copy to \" c/\\303\\205ngstr\\303\\266m\"\n");
 271                 int ptr = fh.parseGitFileName(0, fh.buf.length);
 272                 assertTrue(ptr > 0);
 273                 assertNull(fh.getOldName()); // can't parse names on a copy
 274                 assertNull(fh.getNewName());
 275
 276                 ptr = fh.parseGitHeaders(ptr, fh.buf.length);
 277                 assertTrue(ptr > 0);
 278
 279                 assertEquals("a", fh.getOldName());
 280                 assertEquals(" c/\u00c5ngstr\u00f6m", fh.getNewName());
 281
 282                 assertSame(FileHeader.ChangeType.COPY, fh.getChangeType());
 283                 assertSame(FileHeader.PatchType.UNIFIED, fh.getPatchType());
 284                 assertTrue(fh.hasMetaDataChanges());
 285
 286                 assertNull(fh.getOldId());
 287                 assertNull(fh.getNewId());
 288
 289                 assertNull(fh.getOldMode());
 290                 assertNull(fh.getNewMode());
 291
 292                 assertEquals(100, fh.getScore());
 293         }
 294
 295         public void testParseFullIndexLine_WithMode() {
 296                 final String oid = "78981922613b2afb6025042ff6bd878ac1994e85";
 297                 final String nid = "61780798228d17af2d34fce4cfbdf35556832472";
 298                 final FileHeader fh = data("diff --git a/a b/a\n" + "index " + oid
 299                                 + ".." + nid + " 100644\n" + "--- a/a\n" + "+++ b/a\n");
 300                 assertParse(fh);
 301
 302                 assertEquals("a", fh.getOldName());
 303                 assertEquals("a", fh.getNewName());
 304
 305                 assertSame(FileMode.REGULAR_FILE, fh.getOldMode());
 306                 assertSame(FileMode.REGULAR_FILE, fh.getNewMode());
 307                 assertFalse(fh.hasMetaDataChanges());
 308
 309                 assertNotNull(fh.getOldId());
 310                 assertNotNull(fh.getNewId());
 311
 312                 assertTrue(fh.getOldId().isComplete());
 313                 assertTrue(fh.getNewId().isComplete());
 314
 315                 assertEquals(ObjectId.fromString(oid), fh.getOldId().toObjectId());
 316                 assertEquals(ObjectId.fromString(nid), fh.getNewId().toObjectId());
 317         }
 318
 319         public void testParseFullIndexLine_NoMode() {
 320                 final String oid = "78981922613b2afb6025042ff6bd878ac1994e85";
 321                 final String nid = "61780798228d17af2d34fce4cfbdf35556832472";
 322                 final FileHeader fh = data("diff --git a/a b/a\n" + "index " + oid
 323                                 + ".." + nid + "\n" + "--- a/a\n" + "+++ b/a\n");
 324                 assertParse(fh);
 325
 326                 assertEquals("a", fh.getOldName());
 327                 assertEquals("a", fh.getNewName());
 328                 assertFalse(fh.hasMetaDataChanges());
 329
 330                 assertNull(fh.getOldMode());
 331                 assertNull(fh.getNewMode());
 332
 333                 assertNotNull(fh.getOldId());
 334                 assertNotNull(fh.getNewId());
 335
 336                 assertTrue(fh.getOldId().isComplete());
 337                 assertTrue(fh.getNewId().isComplete());
 338
 339                 assertEquals(ObjectId.fromString(oid), fh.getOldId().toObjectId());
 340                 assertEquals(ObjectId.fromString(nid), fh.getNewId().toObjectId());
 341         }
 342
 343         public void testParseAbbrIndexLine_WithMode() {
 344                 final int a = 7;
 345                 final String oid = "78981922613b2afb6025042ff6bd878ac1994e85";
 346                 final String nid = "61780798228d17af2d34fce4cfbdf35556832472";
 347                 final FileHeader fh = data("diff --git a/a b/a\n" + "index "
 348                                 + oid.substring(0, a - 1) + ".." + nid.substring(0, a - 1)
 349                                 + " 100644\n" + "--- a/a\n" + "+++ b/a\n");
 350                 assertParse(fh);
 351
 352                 assertEquals("a", fh.getOldName());
 353                 assertEquals("a", fh.getNewName());
 354
 355                 assertSame(FileMode.REGULAR_FILE, fh.getOldMode());
 356                 assertSame(FileMode.REGULAR_FILE, fh.getNewMode());
 357                 assertFalse(fh.hasMetaDataChanges());
 358
 359                 assertNotNull(fh.getOldId());
 360                 assertNotNull(fh.getNewId());
 361
 362                 assertFalse(fh.getOldId().isComplete());
 363                 assertFalse(fh.getNewId().isComplete());
 364
 365                 assertEquals(oid.substring(0, a - 1), fh.getOldId().name());
 366                 assertEquals(nid.substring(0, a - 1), fh.getNewId().name());
 367
 368                 assertTrue(ObjectId.fromString(oid).startsWith(fh.getOldId()));
 369                 assertTrue(ObjectId.fromString(nid).startsWith(fh.getNewId()));
 370         }
 371
 372         public void testParseAbbrIndexLine_NoMode() {
 373                 final int a = 7;
 374                 final String oid = "78981922613b2afb6025042ff6bd878ac1994e85";
 375                 final String nid = "61780798228d17af2d34fce4cfbdf35556832472";
 376                 final FileHeader fh = data("diff --git a/a b/a\n" + "index "
 377                                 + oid.substring(0, a - 1) + ".." + nid.substring(0, a - 1)
 378                                 + "\n" + "--- a/a\n" + "+++ b/a\n");
 379                 assertParse(fh);
 380
 381                 assertEquals("a", fh.getOldName());
 382                 assertEquals("a", fh.getNewName());
 383
 384                 assertNull(fh.getOldMode());
 385                 assertNull(fh.getNewMode());
 386                 assertFalse(fh.hasMetaDataChanges());
 387
 388                 assertNotNull(fh.getOldId());
 389                 assertNotNull(fh.getNewId());
 390
 391                 assertFalse(fh.getOldId().isComplete());
 392                 assertFalse(fh.getNewId().isComplete());
 393
 394                 assertEquals(oid.substring(0, a - 1), fh.getOldId().name());
 395                 assertEquals(nid.substring(0, a - 1), fh.getNewId().name());
 396
 397                 assertTrue(ObjectId.fromString(oid).startsWith(fh.getOldId()));
 398                 assertTrue(ObjectId.fromString(nid).startsWith(fh.getNewId()));
 399         }
 400
 401         private static void assertParse(final FileHeader fh) {
 402                 int ptr = fh.parseGitFileName(0, fh.buf.length);
 403                 assertTrue(ptr > 0);
 404                 ptr = fh.parseGitHeaders(ptr, fh.buf.length);
 405                 assertTrue(ptr > 0);
 406         }
 407
 408         private static FileHeader data(final String in) {
 409                 return new FileHeader(Constants.encodeASCII(in), 0);
 410         }
 411
 412         private static FileHeader header(final String path) {
 413                 return data(gitLine(path) + "--- " + path + "\n");
 414         }
 415
 416         private static String gitLine(final String path) {
 417                 return "a/" + path + " b/" + path + "\n";
 418         }
 419
 420         private static FileHeader dqHeader(final String path) {
 421                 return data(dqGitLine(path) + "--- " + path + "\n");
 422         }
 423
 424         private static String dqGitLine(final String path) {
 425                 return "\"a/" + path + "\" \"b/" + path + "\"\n";
 426         }
 427 }