org.spearce.jgit.test/tst/org/spearce/jgit/lib/ObjectCheckerTest.java

   1 /*
   2  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
   3  * Copyright (C) 2008, Google Inc.
   4  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or
   8  * without modification, are permitted provided that the following
   9  * conditions are met:
  10  *
  11  * - Redistributions of source code must retain the above copyright
  12  *   notice, this list of conditions and the following disclaimer.
  13  *
  14  * - Redistributions in binary form must reproduce the above
  15  *   copyright notice, this list of conditions and the following
  16  *   disclaimer in the documentation and/or other materials provided
  17  *   with the distribution.
  18  *
  19  * - Neither the name of the Git Development Community nor the
  20  *   names of its contributors may be used to endorse or promote
  21  *   products derived from this software without specific prior
  22  *   written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  25  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  26  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  29  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  31  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  32  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  33  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  34  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 package org.spearce.jgit.lib;
  40
  41 import junit.framework.TestCase;
  42
  43 import org.spearce.jgit.errors.CorruptObjectException;
  44
  45 public class ObjectCheckerTest extends TestCase {
  46         private ObjectChecker checker;
  47
  48         protected void setUp() throws Exception {
  49                 super.setUp();
  50                 checker = new ObjectChecker();
  51         }
  52
  53         public void testInvalidType() {
  54                 try {
  55                         checker.check(Constants.OBJ_BAD, new byte[0]);
  56                         fail("Did not throw CorruptObjectException");
  57                 } catch (CorruptObjectException e) {
  58                         final String m = e.getMessage();
  59                         assertEquals("Invalid object type: " + Constants.OBJ_BAD, m);
  60                 }
  61         }
  62
  63         public void testCheckBlob() throws CorruptObjectException {
  64                 // Any blob should pass...
  65                 checker.checkBlob(new byte[0]);
  66                 checker.checkBlob(new byte[1]);
  67
  68                 checker.check(Constants.OBJ_BLOB, new byte[0]);
  69                 checker.check(Constants.OBJ_BLOB, new byte[1]);
  70         }
  71
  72         public void testValidCommitNoParent() throws CorruptObjectException {
  73                 final StringBuilder b = new StringBuilder();
  74
  75                 b.append("tree ");
  76                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
  77                 b.append('\n');
  78
  79                 b.append("author A. U. Thor <author@localhost> 1 +0000\n");
  80                 b.append("committer A. U. Thor <author@localhost> 1 +0000\n");
  81
  82                 final byte[] data = Constants.encodeASCII(b.toString());
  83                 checker.checkCommit(data);
  84                 checker.check(Constants.OBJ_COMMIT, data);
  85         }
  86
  87         public void testValidCommitBlankAuthor() throws CorruptObjectException {
  88                 final StringBuilder b = new StringBuilder();
  89
  90                 b.append("tree ");
  91                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
  92                 b.append('\n');
  93
  94                 b.append("author <> 0 +0000\n");
  95                 b.append("committer <> 0 +0000\n");
  96
  97                 final byte[] data = Constants.encodeASCII(b.toString());
  98                 checker.checkCommit(data);
  99                 checker.check(Constants.OBJ_COMMIT, data);
 100         }
 101
 102         public void testValidCommit1Parent() throws CorruptObjectException {
 103                 final StringBuilder b = new StringBuilder();
 104
 105                 b.append("tree ");
 106                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 107                 b.append('\n');
 108
 109                 b.append("parent ");
 110                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 111                 b.append('\n');
 112
 113                 b.append("author A. U. Thor <author@localhost> 1 +0000\n");
 114                 b.append("committer A. U. Thor <author@localhost> 1 +0000\n");
 115
 116                 final byte[] data = Constants.encodeASCII(b.toString());
 117                 checker.checkCommit(data);
 118                 checker.check(Constants.OBJ_COMMIT, data);
 119         }
 120
 121         public void testValidCommit2Parent() throws CorruptObjectException {
 122                 final StringBuilder b = new StringBuilder();
 123
 124                 b.append("tree ");
 125                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 126                 b.append('\n');
 127
 128                 b.append("parent ");
 129                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 130                 b.append('\n');
 131
 132                 b.append("parent ");
 133                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 134                 b.append('\n');
 135
 136                 b.append("author A. U. Thor <author@localhost> 1 +0000\n");
 137                 b.append("committer A. U. Thor <author@localhost> 1 +0000\n");
 138
 139                 final byte[] data = Constants.encodeASCII(b.toString());
 140                 checker.checkCommit(data);
 141                 checker.check(Constants.OBJ_COMMIT, data);
 142         }
 143
 144         public void testValidCommit128Parent() throws CorruptObjectException {
 145                 final StringBuilder b = new StringBuilder();
 146
 147                 b.append("tree ");
 148                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 149                 b.append('\n');
 150
 151                 for (int i = 0; i < 128; i++) {
 152                         b.append("parent ");
 153                         b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 154                         b.append('\n');
 155                 }
 156
 157                 b.append("author A. U. Thor <author@localhost> 1 +0000\n");
 158                 b.append("committer A. U. Thor <author@localhost> 1 +0000\n");
 159
 160                 final byte[] data = Constants.encodeASCII(b.toString());
 161                 checker.checkCommit(data);
 162                 checker.check(Constants.OBJ_COMMIT, data);
 163         }
 164
 165         public void testValidCommitNormalTime() throws CorruptObjectException {
 166                 final StringBuilder b = new StringBuilder();
 167                 final String when = "1222757360 -0730";
 168
 169                 b.append("tree ");
 170                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 171                 b.append('\n');
 172
 173                 b.append("author A. U. Thor <author@localhost> " + when + "\n");
 174                 b.append("committer A. U. Thor <author@localhost> " + when + "\n");
 175
 176                 final byte[] data = Constants.encodeASCII(b.toString());
 177                 checker.checkCommit(data);
 178                 checker.check(Constants.OBJ_COMMIT, data);
 179         }
 180
 181         public void testInvalidCommitNoTree1() {
 182                 final StringBuilder b = new StringBuilder();
 183
 184                 b.append("parent ");
 185                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 186                 b.append('\n');
 187
 188                 final byte[] data = Constants.encodeASCII(b.toString());
 189                 try {
 190                         checker.checkCommit(data);
 191                         fail("Did not catch corrupt object");
 192                 } catch (CorruptObjectException e) {
 193                         assertEquals("no tree header", e.getMessage());
 194                 }
 195         }
 196
 197         public void testInvalidCommitNoTree2() {
 198                 final StringBuilder b = new StringBuilder();
 199
 200                 b.append("trie ");
 201                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 202                 b.append('\n');
 203
 204                 final byte[] data = Constants.encodeASCII(b.toString());
 205                 try {
 206                         checker.checkCommit(data);
 207                         fail("Did not catch corrupt object");
 208                 } catch (CorruptObjectException e) {
 209                         assertEquals("no tree header", e.getMessage());
 210                 }
 211         }
 212
 213         public void testInvalidCommitNoTree3() {
 214                 final StringBuilder b = new StringBuilder();
 215
 216                 b.append("tree");
 217                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 218                 b.append('\n');
 219
 220                 final byte[] data = Constants.encodeASCII(b.toString());
 221                 try {
 222                         checker.checkCommit(data);
 223                         fail("Did not catch corrupt object");
 224                 } catch (CorruptObjectException e) {
 225                         assertEquals("no tree header", e.getMessage());
 226                 }
 227         }
 228
 229         public void testInvalidCommitNoTree4() {
 230                 final StringBuilder b = new StringBuilder();
 231
 232                 b.append("tree\t");
 233                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 234                 b.append('\n');
 235
 236                 final byte[] data = Constants.encodeASCII(b.toString());
 237                 try {
 238                         checker.checkCommit(data);
 239                         fail("Did not catch corrupt object");
 240                 } catch (CorruptObjectException e) {
 241                         assertEquals("no tree header", e.getMessage());
 242                 }
 243         }
 244
 245         public void testInvalidCommitInvalidTree1() {
 246                 final StringBuilder b = new StringBuilder();
 247
 248                 b.append("tree ");
 249                 b.append("zzzzfa841874ccc9f2ef7c48d0c76226f89b7189");
 250                 b.append('\n');
 251
 252                 final byte[] data = Constants.encodeASCII(b.toString());
 253                 try {
 254                         checker.checkCommit(data);
 255                         fail("Did not catch corrupt object");
 256                 } catch (CorruptObjectException e) {
 257                         assertEquals("invalid tree", e.getMessage());
 258                 }
 259         }
 260
 261         public void testInvalidCommitInvalidTree2() {
 262                 final StringBuilder b = new StringBuilder();
 263
 264                 b.append("tree ");
 265                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 266                 b.append("z\n");
 267
 268                 final byte[] data = Constants.encodeASCII(b.toString());
 269                 try {
 270                         checker.checkCommit(data);
 271                         fail("Did not catch corrupt object");
 272                 } catch (CorruptObjectException e) {
 273                         assertEquals("invalid tree", e.getMessage());
 274                 }
 275         }
 276
 277         public void testInvalidCommitInvalidTree3() {
 278                 final StringBuilder b = new StringBuilder();
 279
 280                 b.append("tree ");
 281                 b.append("be9b");
 282                 b.append("\n");
 283
 284                 final byte[] data = Constants.encodeASCII(b.toString());
 285                 try {
 286                         checker.checkCommit(data);
 287                         fail("Did not catch corrupt object");
 288                 } catch (CorruptObjectException e) {
 289                         assertEquals("invalid tree", e.getMessage());
 290                 }
 291         }
 292
 293         public void testInvalidCommitInvalidTree4() {
 294                 final StringBuilder b = new StringBuilder();
 295
 296                 b.append("tree  ");
 297                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 298                 b.append('\n');
 299
 300                 final byte[] data = Constants.encodeASCII(b.toString());
 301                 try {
 302                         checker.checkCommit(data);
 303                         fail("Did not catch corrupt object");
 304                 } catch (CorruptObjectException e) {
 305                         assertEquals("invalid tree", e.getMessage());
 306                 }
 307         }
 308
 309         public void testInvalidCommitInvalidParent1() {
 310                 final StringBuilder b = new StringBuilder();
 311
 312                 b.append("tree ");
 313                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 314                 b.append('\n');
 315
 316                 b.append("parent ");
 317                 b.append("\n");
 318
 319                 final byte[] data = Constants.encodeASCII(b.toString());
 320                 try {
 321                         checker.checkCommit(data);
 322                         fail("Did not catch corrupt object");
 323                 } catch (CorruptObjectException e) {
 324                         assertEquals("invalid parent", e.getMessage());
 325                 }
 326         }
 327
 328         public void testInvalidCommitInvalidParent2() {
 329                 final StringBuilder b = new StringBuilder();
 330
 331                 b.append("tree ");
 332                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 333                 b.append('\n');
 334
 335                 b.append("parent ");
 336                 b.append("zzzzfa841874ccc9f2ef7c48d0c76226f89b7189");
 337                 b.append("\n");
 338
 339                 final byte[] data = Constants.encodeASCII(b.toString());
 340                 try {
 341                         checker.checkCommit(data);
 342                         fail("Did not catch corrupt object");
 343                 } catch (CorruptObjectException e) {
 344                         assertEquals("invalid parent", e.getMessage());
 345                 }
 346         }
 347
 348         public void testInvalidCommitInvalidParent3() {
 349                 final StringBuilder b = new StringBuilder();
 350
 351                 b.append("tree ");
 352                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 353                 b.append('\n');
 354
 355                 b.append("parent  ");
 356                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 357                 b.append("\n");
 358
 359                 final byte[] data = Constants.encodeASCII(b.toString());
 360                 try {
 361                         checker.checkCommit(data);
 362                         fail("Did not catch corrupt object");
 363                 } catch (CorruptObjectException e) {
 364                         assertEquals("invalid parent", e.getMessage());
 365                 }
 366         }
 367
 368         public void testInvalidCommitInvalidParent4() {
 369                 final StringBuilder b = new StringBuilder();
 370
 371                 b.append("tree ");
 372                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 373                 b.append('\n');
 374
 375                 b.append("parent  ");
 376                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 377                 b.append("z\n");
 378
 379                 final byte[] data = Constants.encodeASCII(b.toString());
 380                 try {
 381                         checker.checkCommit(data);
 382                         fail("Did not catch corrupt object");
 383                 } catch (CorruptObjectException e) {
 384                         assertEquals("invalid parent", e.getMessage());
 385                 }
 386         }
 387
 388         public void testInvalidCommitInvalidParent5() {
 389                 final StringBuilder b = new StringBuilder();
 390
 391                 b.append("tree ");
 392                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 393                 b.append('\n');
 394
 395                 b.append("parent\t");
 396                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 397                 b.append("\n");
 398
 399                 final byte[] data = Constants.encodeASCII(b.toString());
 400                 try {
 401                         checker.checkCommit(data);
 402                         fail("Did not catch corrupt object");
 403                 } catch (CorruptObjectException e) {
 404                         // Yes, really, we complain about author not being
 405                         // found as the invalid parent line wasn't consumed.
 406                         assertEquals("no author", e.getMessage());
 407                 }
 408         }
 409
 410         public void testInvalidCommitNoAuthor() {
 411                 final StringBuilder b = new StringBuilder();
 412
 413                 b.append("tree ");
 414                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 415                 b.append('\n');
 416
 417                 b.append("committer A. U. Thor <author@localhost> 1 +0000\n");
 418
 419                 final byte[] data = Constants.encodeASCII(b.toString());
 420                 try {
 421                         checker.checkCommit(data);
 422                         fail("Did not catch corrupt object");
 423                 } catch (CorruptObjectException e) {
 424                         // Yes, really, we complain about author not being
 425                         // found as the invalid parent line wasn't consumed.
 426                         assertEquals("no author", e.getMessage());
 427                 }
 428         }
 429
 430         public void testInvalidCommitNoCommitter1() {
 431                 final StringBuilder b = new StringBuilder();
 432
 433                 b.append("tree ");
 434                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 435                 b.append('\n');
 436
 437                 b.append("author A. U. Thor <author@localhost> 1 +0000\n");
 438
 439                 final byte[] data = Constants.encodeASCII(b.toString());
 440                 try {
 441                         checker.checkCommit(data);
 442                         fail("Did not catch corrupt object");
 443                 } catch (CorruptObjectException e) {
 444                         // Yes, really, we complain about author not being
 445                         // found as the invalid parent line wasn't consumed.
 446                         assertEquals("no committer", e.getMessage());
 447                 }
 448         }
 449
 450         public void testInvalidCommitNoCommitter2() {
 451                 final StringBuilder b = new StringBuilder();
 452
 453                 b.append("tree ");
 454                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 455                 b.append('\n');
 456
 457                 b.append("author A. U. Thor <author@localhost> 1 +0000\n");
 458                 b.append("\n");
 459
 460                 final byte[] data = Constants.encodeASCII(b.toString());
 461                 try {
 462                         checker.checkCommit(data);
 463                         fail("Did not catch corrupt object");
 464                 } catch (CorruptObjectException e) {
 465                         // Yes, really, we complain about author not being
 466                         // found as the invalid parent line wasn't consumed.
 467                         assertEquals("no committer", e.getMessage());
 468                 }
 469         }
 470
 471         public void testInvalidCommitInvalidAuthor1() {
 472                 final StringBuilder b = new StringBuilder();
 473
 474                 b.append("tree ");
 475                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 476                 b.append('\n');
 477
 478                 b.append("author A. U. Thor <foo 1 +0000\n");
 479
 480                 final byte[] data = Constants.encodeASCII(b.toString());
 481                 try {
 482                         checker.checkCommit(data);
 483                         fail("Did not catch corrupt object");
 484                 } catch (CorruptObjectException e) {
 485                         // Yes, really, we complain about author not being
 486                         // found as the invalid parent line wasn't consumed.
 487                         assertEquals("invalid author", e.getMessage());
 488                 }
 489         }
 490
 491         public void testInvalidCommitInvalidAuthor2() {
 492                 final StringBuilder b = new StringBuilder();
 493
 494                 b.append("tree ");
 495                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 496                 b.append('\n');
 497
 498                 b.append("author A. U. Thor foo> 1 +0000\n");
 499
 500                 final byte[] data = Constants.encodeASCII(b.toString());
 501                 try {
 502                         checker.checkCommit(data);
 503                         fail("Did not catch corrupt object");
 504                 } catch (CorruptObjectException e) {
 505                         // Yes, really, we complain about author not being
 506                         // found as the invalid parent line wasn't consumed.
 507                         assertEquals("invalid author", e.getMessage());
 508                 }
 509         }
 510
 511         public void testInvalidCommitInvalidAuthor3() {
 512                 final StringBuilder b = new StringBuilder();
 513
 514                 b.append("tree ");
 515                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 516                 b.append('\n');
 517
 518                 b.append("author 1 +0000\n");
 519
 520                 final byte[] data = Constants.encodeASCII(b.toString());
 521                 try {
 522                         checker.checkCommit(data);
 523                         fail("Did not catch corrupt object");
 524                 } catch (CorruptObjectException e) {
 525                         // Yes, really, we complain about author not being
 526                         // found as the invalid parent line wasn't consumed.
 527                         assertEquals("invalid author", e.getMessage());
 528                 }
 529         }
 530
 531         public void testInvalidCommitInvalidAuthor4() {
 532                 final StringBuilder b = new StringBuilder();
 533
 534                 b.append("tree ");
 535                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 536                 b.append('\n');
 537
 538                 b.append("author a <b> +0000\n");
 539
 540                 final byte[] data = Constants.encodeASCII(b.toString());
 541                 try {
 542                         checker.checkCommit(data);
 543                         fail("Did not catch corrupt object");
 544                 } catch (CorruptObjectException e) {
 545                         // Yes, really, we complain about author not being
 546                         // found as the invalid parent line wasn't consumed.
 547                         assertEquals("invalid author", e.getMessage());
 548                 }
 549         }
 550
 551         public void testInvalidCommitInvalidAuthor5() {
 552                 final StringBuilder b = new StringBuilder();
 553
 554                 b.append("tree ");
 555                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 556                 b.append('\n');
 557
 558                 b.append("author a <b>\n");
 559
 560                 final byte[] data = Constants.encodeASCII(b.toString());
 561                 try {
 562                         checker.checkCommit(data);
 563                         fail("Did not catch corrupt object");
 564                 } catch (CorruptObjectException e) {
 565                         // Yes, really, we complain about author not being
 566                         // found as the invalid parent line wasn't consumed.
 567                         assertEquals("invalid author", e.getMessage());
 568                 }
 569         }
 570
 571         public void testInvalidCommitInvalidAuthor6() {
 572                 final StringBuilder b = new StringBuilder();
 573
 574                 b.append("tree ");
 575                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 576                 b.append('\n');
 577
 578                 b.append("author a <b> z");
 579
 580                 final byte[] data = Constants.encodeASCII(b.toString());
 581                 try {
 582                         checker.checkCommit(data);
 583                         fail("Did not catch corrupt object");
 584                 } catch (CorruptObjectException e) {
 585                         // Yes, really, we complain about author not being
 586                         // found as the invalid parent line wasn't consumed.
 587                         assertEquals("invalid author", e.getMessage());
 588                 }
 589         }
 590
 591         public void testInvalidCommitInvalidAuthor7() {
 592                 final StringBuilder b = new StringBuilder();
 593
 594                 b.append("tree ");
 595                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 596                 b.append('\n');
 597
 598                 b.append("author a <b> 1 z");
 599
 600                 final byte[] data = Constants.encodeASCII(b.toString());
 601                 try {
 602                         checker.checkCommit(data);
 603                         fail("Did not catch corrupt object");
 604                 } catch (CorruptObjectException e) {
 605                         // Yes, really, we complain about author not being
 606                         // found as the invalid parent line wasn't consumed.
 607                         assertEquals("invalid author", e.getMessage());
 608                 }
 609         }
 610
 611         public void testInvalidCommitInvalidCommitter() {
 612                 final StringBuilder b = new StringBuilder();
 613
 614                 b.append("tree ");
 615                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 616                 b.append('\n');
 617
 618                 b.append("author a <b> 1 +0000\n");
 619                 b.append("committer a <");
 620
 621                 final byte[] data = Constants.encodeASCII(b.toString());
 622                 try {
 623                         checker.checkCommit(data);
 624                         fail("Did not catch corrupt object");
 625                 } catch (CorruptObjectException e) {
 626                         // Yes, really, we complain about author not being
 627                         // found as the invalid parent line wasn't consumed.
 628                         assertEquals("invalid committer", e.getMessage());
 629                 }
 630         }
 631
 632         public void testValidTag() throws CorruptObjectException {
 633                 final StringBuilder b = new StringBuilder();
 634
 635                 b.append("object ");
 636                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 637                 b.append('\n');
 638
 639                 b.append("type commit\n");
 640                 b.append("tag test-tag\n");
 641                 b.append("tagger A. U. Thor <author@localhost> 1 +0000\n");
 642
 643                 final byte[] data = Constants.encodeASCII(b.toString());
 644                 checker.checkTag(data);
 645                 checker.check(Constants.OBJ_TAG, data);
 646         }
 647
 648         public void testInvalidTagNoObject1() {
 649                 final StringBuilder b = new StringBuilder();
 650
 651                 final byte[] data = Constants.encodeASCII(b.toString());
 652                 try {
 653                         checker.checkTag(data);
 654                         fail("incorrectly accepted invalid tag");
 655                 } catch (CorruptObjectException e) {
 656                         assertEquals("no object header", e.getMessage());
 657                 }
 658         }
 659
 660         public void testInvalidTagNoObject2() {
 661                 final StringBuilder b = new StringBuilder();
 662
 663                 b.append("object\t");
 664                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 665                 b.append('\n');
 666
 667                 final byte[] data = Constants.encodeASCII(b.toString());
 668                 try {
 669                         checker.checkTag(data);
 670                         fail("incorrectly accepted invalid tag");
 671                 } catch (CorruptObjectException e) {
 672                         assertEquals("no object header", e.getMessage());
 673                 }
 674         }
 675
 676         public void testInvalidTagNoObject3() {
 677                 final StringBuilder b = new StringBuilder();
 678
 679                 b.append("obejct ");
 680                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 681                 b.append('\n');
 682
 683                 final byte[] data = Constants.encodeASCII(b.toString());
 684                 try {
 685                         checker.checkTag(data);
 686                         fail("incorrectly accepted invalid tag");
 687                 } catch (CorruptObjectException e) {
 688                         assertEquals("no object header", e.getMessage());
 689                 }
 690         }
 691
 692         public void testInvalidTagNoObject4() {
 693                 final StringBuilder b = new StringBuilder();
 694
 695                 b.append("object ");
 696                 b.append("zz9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 697                 b.append('\n');
 698
 699                 final byte[] data = Constants.encodeASCII(b.toString());
 700                 try {
 701                         checker.checkTag(data);
 702                         fail("incorrectly accepted invalid tag");
 703                 } catch (CorruptObjectException e) {
 704                         assertEquals("invalid object", e.getMessage());
 705                 }
 706         }
 707
 708         public void testInvalidTagNoObject5() {
 709                 final StringBuilder b = new StringBuilder();
 710
 711                 b.append("object ");
 712                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 713                 b.append(" \n");
 714
 715                 final byte[] data = Constants.encodeASCII(b.toString());
 716                 try {
 717                         checker.checkTag(data);
 718                         fail("incorrectly accepted invalid tag");
 719                 } catch (CorruptObjectException e) {
 720                         assertEquals("invalid object", e.getMessage());
 721                 }
 722         }
 723
 724         public void testInvalidTagNoObject6() {
 725                 final StringBuilder b = new StringBuilder();
 726
 727                 b.append("object ");
 728                 b.append("be9");
 729
 730                 final byte[] data = Constants.encodeASCII(b.toString());
 731                 try {
 732                         checker.checkTag(data);
 733                         fail("incorrectly accepted invalid tag");
 734                 } catch (CorruptObjectException e) {
 735                         assertEquals("invalid object", e.getMessage());
 736                 }
 737         }
 738
 739         public void testInvalidTagNoType1() {
 740                 final StringBuilder b = new StringBuilder();
 741
 742                 b.append("object ");
 743                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 744                 b.append('\n');
 745
 746                 final byte[] data = Constants.encodeASCII(b.toString());
 747                 try {
 748                         checker.checkTag(data);
 749                         fail("incorrectly accepted invalid tag");
 750                 } catch (CorruptObjectException e) {
 751                         assertEquals("no type header", e.getMessage());
 752                 }
 753         }
 754
 755         public void testInvalidTagNoType2() {
 756                 final StringBuilder b = new StringBuilder();
 757
 758                 b.append("object ");
 759                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 760                 b.append('\n');
 761
 762                 b.append("type\tcommit\n");
 763
 764                 final byte[] data = Constants.encodeASCII(b.toString());
 765                 try {
 766                         checker.checkTag(data);
 767                         fail("incorrectly accepted invalid tag");
 768                 } catch (CorruptObjectException e) {
 769                         assertEquals("no type header", e.getMessage());
 770                 }
 771         }
 772
 773         public void testInvalidTagNoType3() {
 774                 final StringBuilder b = new StringBuilder();
 775
 776                 b.append("object ");
 777                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 778                 b.append('\n');
 779
 780                 b.append("tpye commit\n");
 781
 782                 final byte[] data = Constants.encodeASCII(b.toString());
 783                 try {
 784                         checker.checkTag(data);
 785                         fail("incorrectly accepted invalid tag");
 786                 } catch (CorruptObjectException e) {
 787                         assertEquals("no type header", e.getMessage());
 788                 }
 789         }
 790
 791         public void testInvalidTagNoType4() {
 792                 final StringBuilder b = new StringBuilder();
 793
 794                 b.append("object ");
 795                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 796                 b.append('\n');
 797
 798                 b.append("type commit");
 799
 800                 final byte[] data = Constants.encodeASCII(b.toString());
 801                 try {
 802                         checker.checkTag(data);
 803                         fail("incorrectly accepted invalid tag");
 804                 } catch (CorruptObjectException e) {
 805                         assertEquals("no tag header", e.getMessage());
 806                 }
 807         }
 808
 809         public void testInvalidTagNoTagHeader1() {
 810                 final StringBuilder b = new StringBuilder();
 811
 812                 b.append("object ");
 813                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 814                 b.append('\n');
 815
 816                 b.append("type commit\n");
 817
 818                 final byte[] data = Constants.encodeASCII(b.toString());
 819                 try {
 820                         checker.checkTag(data);
 821                         fail("incorrectly accepted invalid tag");
 822                 } catch (CorruptObjectException e) {
 823                         assertEquals("no tag header", e.getMessage());
 824                 }
 825         }
 826
 827         public void testInvalidTagNoTagHeader2() {
 828                 final StringBuilder b = new StringBuilder();
 829
 830                 b.append("object ");
 831                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 832                 b.append('\n');
 833
 834                 b.append("type commit\n");
 835                 b.append("tag\tfoo\n");
 836
 837                 final byte[] data = Constants.encodeASCII(b.toString());
 838                 try {
 839                         checker.checkTag(data);
 840                         fail("incorrectly accepted invalid tag");
 841                 } catch (CorruptObjectException e) {
 842                         assertEquals("no tag header", e.getMessage());
 843                 }
 844         }
 845
 846         public void testInvalidTagNoTagHeader3() {
 847                 final StringBuilder b = new StringBuilder();
 848
 849                 b.append("object ");
 850                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 851                 b.append('\n');
 852
 853                 b.append("type commit\n");
 854                 b.append("tga foo\n");
 855
 856                 final byte[] data = Constants.encodeASCII(b.toString());
 857                 try {
 858                         checker.checkTag(data);
 859                         fail("incorrectly accepted invalid tag");
 860                 } catch (CorruptObjectException e) {
 861                         assertEquals("no tag header", e.getMessage());
 862                 }
 863         }
 864
 865         public void testInvalidTagNoTagHeader4() {
 866                 final StringBuilder b = new StringBuilder();
 867
 868                 b.append("object ");
 869                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 870                 b.append('\n');
 871
 872                 b.append("type commit\n");
 873                 b.append("tag foo");
 874
 875                 final byte[] data = Constants.encodeASCII(b.toString());
 876                 try {
 877                         checker.checkTag(data);
 878                         fail("incorrectly accepted invalid tag");
 879                 } catch (CorruptObjectException e) {
 880                         assertEquals("no tagger header", e.getMessage());
 881                 }
 882         }
 883
 884         public void testInvalidTagNoTaggerHeader1() {
 885                 final StringBuilder b = new StringBuilder();
 886
 887                 b.append("object ");
 888                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 889                 b.append('\n');
 890
 891                 b.append("type commit\n");
 892                 b.append("tag foo\n");
 893
 894                 final byte[] data = Constants.encodeASCII(b.toString());
 895                 try {
 896                         checker.checkTag(data);
 897                         fail("incorrectly accepted invalid tag");
 898                 } catch (CorruptObjectException e) {
 899                         assertEquals("no tagger header", e.getMessage());
 900                 }
 901         }
 902
 903         public void testInvalidTagInvalidTaggerHeader1() {
 904                 final StringBuilder b = new StringBuilder();
 905
 906                 b.append("object ");
 907                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 908                 b.append('\n');
 909
 910                 b.append("type commit\n");
 911                 b.append("tag foo\n");
 912                 b.append("tagger \n");
 913
 914                 final byte[] data = Constants.encodeASCII(b.toString());
 915                 try {
 916                         checker.checkTag(data);
 917                         fail("incorrectly accepted invalid tag");
 918                 } catch (CorruptObjectException e) {
 919                         assertEquals("invalid tagger", e.getMessage());
 920                 }
 921         }
 922
 923         public void testInvalidTagInvalidTaggerHeader3() {
 924                 final StringBuilder b = new StringBuilder();
 925
 926                 b.append("object ");
 927                 b.append("be9bfa841874ccc9f2ef7c48d0c76226f89b7189");
 928                 b.append('\n');
 929
 930                 b.append("type commit\n");
 931                 b.append("tag foo\n");
 932                 b.append("tagger a < 1 +000\n");
 933
 934                 final byte[] data = Constants.encodeASCII(b.toString());
 935                 try {
 936                         checker.checkTag(data);
 937                         fail("incorrectly accepted invalid tag");
 938                 } catch (CorruptObjectException e) {
 939                         assertEquals("invalid tagger", e.getMessage());
 940                 }
 941         }
 942
 943         public void testValidEmptyTree() throws CorruptObjectException {
 944                 checker.checkTree(new byte[0]);
 945                 checker.check(Constants.OBJ_TREE, new byte[0]);
 946         }
 947
 948         public void testValidTree1() throws CorruptObjectException {
 949                 final StringBuilder b = new StringBuilder();
 950                 entry(b, "100644 regular-file");
 951                 final byte[] data = Constants.encodeASCII(b.toString());
 952                 checker.checkTree(data);
 953         }
 954
 955         public void testValidTree2() throws CorruptObjectException {
 956                 final StringBuilder b = new StringBuilder();
 957                 entry(b, "100755 executable");
 958                 final byte[] data = Constants.encodeASCII(b.toString());
 959                 checker.checkTree(data);
 960         }
 961
 962         public void testValidTree3() throws CorruptObjectException {
 963                 final StringBuilder b = new StringBuilder();
 964                 entry(b, "40000 tree");
 965                 final byte[] data = Constants.encodeASCII(b.toString());
 966                 checker.checkTree(data);
 967         }
 968
 969         public void testValidTree4() throws CorruptObjectException {
 970                 final StringBuilder b = new StringBuilder();
 971                 entry(b, "120000 symlink");
 972                 final byte[] data = Constants.encodeASCII(b.toString());
 973                 checker.checkTree(data);
 974         }
 975
 976         public void testValidTree5() throws CorruptObjectException {
 977                 final StringBuilder b = new StringBuilder();
 978                 entry(b, "160000 git link");
 979                 final byte[] data = Constants.encodeASCII(b.toString());
 980                 checker.checkTree(data);
 981         }
 982
 983         public void testValidTree6() throws CorruptObjectException {
 984                 final StringBuilder b = new StringBuilder();
 985                 entry(b, "100644 .a");
 986                 final byte[] data = Constants.encodeASCII(b.toString());
 987                 checker.checkTree(data);
 988         }
 989
 990         public void testValidTreeSorting1() throws CorruptObjectException {
 991                 final StringBuilder b = new StringBuilder();
 992                 entry(b, "100644 fooaaa");
 993                 entry(b, "100755 foobar");
 994                 final byte[] data = Constants.encodeASCII(b.toString());
 995                 checker.checkTree(data);
 996         }
 997
 998         public void testValidTreeSorting2() throws CorruptObjectException {
 999                 final StringBuilder b = new StringBuilder();
1000                 entry(b, "100755 fooaaa");
1001                 entry(b, "100644 foobar");
1002                 final byte[] data = Constants.encodeASCII(b.toString());
1003                 checker.checkTree(data);
1004         }
1005
1006         public void testValidTreeSorting3() throws CorruptObjectException {
1007                 final StringBuilder b = new StringBuilder();
1008                 entry(b, "40000 a");
1009                 entry(b, "100644 b");
1010                 final byte[] data = Constants.encodeASCII(b.toString());
1011                 checker.checkTree(data);
1012         }
1013
1014         public void testValidTreeSorting4() throws CorruptObjectException {
1015                 final StringBuilder b = new StringBuilder();
1016                 entry(b, "100644 a");
1017                 entry(b, "40000 b");
1018                 final byte[] data = Constants.encodeASCII(b.toString());
1019                 checker.checkTree(data);
1020         }
1021
1022         public void testValidTreeSorting5() throws CorruptObjectException {
1023                 final StringBuilder b = new StringBuilder();
1024                 entry(b, "100644 a.c");
1025                 entry(b, "40000 a");
1026                 entry(b, "100644 a0c");
1027                 final byte[] data = Constants.encodeASCII(b.toString());
1028                 checker.checkTree(data);
1029         }
1030
1031         public void testValidTreeSorting6() throws CorruptObjectException {
1032                 final StringBuilder b = new StringBuilder();
1033                 entry(b, "40000 a");
1034                 entry(b, "100644 apple");
1035                 final byte[] data = Constants.encodeASCII(b.toString());
1036                 checker.checkTree(data);
1037         }
1038
1039         public void testValidTreeSorting7() throws CorruptObjectException {
1040                 final StringBuilder b = new StringBuilder();
1041                 entry(b, "40000 an orang");
1042                 entry(b, "40000 an orange");
1043                 final byte[] data = Constants.encodeASCII(b.toString());
1044                 checker.checkTree(data);
1045         }
1046
1047         public void testValidTreeSorting8() throws CorruptObjectException {
1048                 final StringBuilder b = new StringBuilder();
1049                 entry(b, "100644 a");
1050                 entry(b, "100644 a0c");
1051                 entry(b, "100644 b");
1052                 final byte[] data = Constants.encodeASCII(b.toString());
1053                 checker.checkTree(data);
1054         }
1055
1056         public void testInvalidTreeModeStartsWithZero1() {
1057                 final StringBuilder b = new StringBuilder();
1058                 entry(b, "0 a");
1059                 final byte[] data = Constants.encodeASCII(b.toString());
1060                 try {
1061                         checker.checkTree(data);
1062                         fail("incorrectly accepted an invalid tree");
1063                 } catch (CorruptObjectException e) {
1064                         assertEquals("mode starts with '0'", e.getMessage());
1065                 }
1066         }
1067
1068         public void testInvalidTreeModeStartsWithZero2() {
1069                 final StringBuilder b = new StringBuilder();
1070                 entry(b, "0100644 a");
1071                 final byte[] data = Constants.encodeASCII(b.toString());
1072                 try {
1073                         checker.checkTree(data);
1074                         fail("incorrectly accepted an invalid tree");
1075                 } catch (CorruptObjectException e) {
1076                         assertEquals("mode starts with '0'", e.getMessage());
1077                 }
1078         }
1079
1080         public void testInvalidTreeModeStartsWithZero3() {
1081                 final StringBuilder b = new StringBuilder();
1082                 entry(b, "040000 a");
1083                 final byte[] data = Constants.encodeASCII(b.toString());
1084                 try {
1085                         checker.checkTree(data);
1086                         fail("incorrectly accepted an invalid tree");
1087                 } catch (CorruptObjectException e) {
1088                         assertEquals("mode starts with '0'", e.getMessage());
1089                 }
1090         }
1091
1092         public void testInvalidTreeModeNotOctal1() {
1093                 final StringBuilder b = new StringBuilder();
1094                 entry(b, "8 a");
1095                 final byte[] data = Constants.encodeASCII(b.toString());
1096                 try {
1097                         checker.checkTree(data);
1098                         fail("incorrectly accepted an invalid tree");
1099                 } catch (CorruptObjectException e) {
1100                         assertEquals("invalid mode character", e.getMessage());
1101                 }
1102         }
1103
1104         public void testInvalidTreeModeNotOctal2() {
1105                 final StringBuilder b = new StringBuilder();
1106                 entry(b, "Z a");
1107                 final byte[] data = Constants.encodeASCII(b.toString());
1108                 try {
1109                         checker.checkTree(data);
1110                         fail("incorrectly accepted an invalid tree");
1111                 } catch (CorruptObjectException e) {
1112                         assertEquals("invalid mode character", e.getMessage());
1113                 }
1114         }
1115
1116         public void testInvalidTreeModeNotSupportedMode1() {
1117                 final StringBuilder b = new StringBuilder();
1118                 entry(b, "1 a");
1119                 final byte[] data = Constants.encodeASCII(b.toString());
1120                 try {
1121                         checker.checkTree(data);
1122                         fail("incorrectly accepted an invalid tree");
1123                 } catch (CorruptObjectException e) {
1124                         assertEquals("invalid mode 1", e.getMessage());
1125                 }
1126         }
1127
1128         public void testInvalidTreeModeNotSupportedMode2() {
1129                 final StringBuilder b = new StringBuilder();
1130                 entry(b, "170000 a");
1131                 final byte[] data = Constants.encodeASCII(b.toString());
1132                 try {
1133                         checker.checkTree(data);
1134                         fail("incorrectly accepted an invalid tree");
1135                 } catch (CorruptObjectException e) {
1136                         assertEquals("invalid mode " + 0170000, e.getMessage());
1137                 }
1138         }
1139
1140         public void testInvalidTreeModeMissingName() {
1141                 final StringBuilder b = new StringBuilder();
1142                 b.append("100644");
1143                 final byte[] data = Constants.encodeASCII(b.toString());
1144                 try {
1145                         checker.checkTree(data);
1146                         fail("incorrectly accepted an invalid tree");
1147                 } catch (CorruptObjectException e) {
1148                         assertEquals("truncated in mode", e.getMessage());
1149                 }
1150         }
1151
1152         public void testInvalidTreeNameContainsSlash() {
1153                 final StringBuilder b = new StringBuilder();
1154                 entry(b, "100644 a/b");
1155                 final byte[] data = Constants.encodeASCII(b.toString());
1156                 try {
1157                         checker.checkTree(data);
1158                         fail("incorrectly accepted an invalid tree");
1159                 } catch (CorruptObjectException e) {
1160                         assertEquals("name contains '/'", e.getMessage());
1161                 }
1162         }
1163
1164         public void testInvalidTreeNameIsEmpty() {
1165                 final StringBuilder b = new StringBuilder();
1166                 entry(b, "100644 ");
1167                 final byte[] data = Constants.encodeASCII(b.toString());
1168                 try {
1169                         checker.checkTree(data);
1170                         fail("incorrectly accepted an invalid tree");
1171                 } catch (CorruptObjectException e) {
1172                         assertEquals("zero length name", e.getMessage());
1173                 }
1174         }
1175
1176         public void testInvalidTreeNameIsDot() {
1177                 final StringBuilder b = new StringBuilder();
1178                 entry(b, "100644 .");
1179                 final byte[] data = Constants.encodeASCII(b.toString());
1180                 try {
1181                         checker.checkTree(data);
1182                         fail("incorrectly accepted an invalid tree");
1183                 } catch (CorruptObjectException e) {
1184                         assertEquals("invalid name '.'", e.getMessage());
1185                 }
1186         }
1187
1188         public void testInvalidTreeNameIsDotDot() {
1189                 final StringBuilder b = new StringBuilder();
1190                 entry(b, "100644 ..");
1191                 final byte[] data = Constants.encodeASCII(b.toString());
1192                 try {
1193                         checker.checkTree(data);
1194                         fail("incorrectly accepted an invalid tree");
1195                 } catch (CorruptObjectException e) {
1196                         assertEquals("invalid name '..'", e.getMessage());
1197                 }
1198         }
1199
1200         public void testInvalidTreeTruncatedInName() {
1201                 final StringBuilder b = new StringBuilder();
1202                 b.append("100644 b");
1203                 final byte[] data = Constants.encodeASCII(b.toString());
1204                 try {
1205                         checker.checkTree(data);
1206                         fail("incorrectly accepted an invalid tree");
1207                 } catch (CorruptObjectException e) {
1208                         assertEquals("truncated in name", e.getMessage());
1209                 }
1210         }
1211
1212         public void testInvalidTreeTruncatedInObjectId() {
1213                 final StringBuilder b = new StringBuilder();
1214                 b.append("100644 b\0\1\2");
1215                 final byte[] data = Constants.encodeASCII(b.toString());
1216                 try {
1217                         checker.checkTree(data);
1218                         fail("incorrectly accepted an invalid tree");
1219                 } catch (CorruptObjectException e) {
1220                         assertEquals("truncated in object id", e.getMessage());
1221                 }
1222         }
1223
1224         public void testInvalidTreeBadSorting1() {
1225                 final StringBuilder b = new StringBuilder();
1226                 entry(b, "100644 foobar");
1227                 entry(b, "100644 fooaaa");
1228                 final byte[] data = Constants.encodeASCII(b.toString());
1229                 try {
1230                         checker.checkTree(data);
1231                         fail("incorrectly accepted an invalid tree");
1232                 } catch (CorruptObjectException e) {
1233                         assertEquals("incorrectly sorted", e.getMessage());
1234                 }
1235         }
1236
1237         public void testInvalidTreeBadSorting2() {
1238                 final StringBuilder b = new StringBuilder();
1239                 entry(b, "40000 a");
1240                 entry(b, "100644 a.c");
1241                 final byte[] data = Constants.encodeASCII(b.toString());
1242                 try {
1243                         checker.checkTree(data);
1244                         fail("incorrectly accepted an invalid tree");
1245                 } catch (CorruptObjectException e) {
1246                         assertEquals("incorrectly sorted", e.getMessage());
1247                 }
1248         }
1249
1250         public void testInvalidTreeBadSorting3() {
1251                 final StringBuilder b = new StringBuilder();
1252                 entry(b, "100644 a0c");
1253                 entry(b, "40000 a");
1254                 final byte[] data = Constants.encodeASCII(b.toString());
1255                 try {
1256                         checker.checkTree(data);
1257                         fail("incorrectly accepted an invalid tree");
1258                 } catch (CorruptObjectException e) {
1259                         assertEquals("incorrectly sorted", e.getMessage());
1260                 }
1261         }
1262
1263         public void testInvalidTreeDuplicateNames1() {
1264                 final StringBuilder b = new StringBuilder();
1265                 entry(b, "100644 a");
1266                 entry(b, "100644 a");
1267                 final byte[] data = Constants.encodeASCII(b.toString());
1268                 try {
1269                         checker.checkTree(data);
1270                         fail("incorrectly accepted an invalid tree");
1271                 } catch (CorruptObjectException e) {
1272                         assertEquals("duplicate entry names", e.getMessage());
1273                 }
1274         }
1275
1276         public void testInvalidTreeDuplicateNames2() {
1277                 final StringBuilder b = new StringBuilder();
1278                 entry(b, "100644 a");
1279                 entry(b, "100755 a");
1280                 final byte[] data = Constants.encodeASCII(b.toString());
1281                 try {
1282                         checker.checkTree(data);
1283                         fail("incorrectly accepted an invalid tree");
1284                 } catch (CorruptObjectException e) {
1285                         assertEquals("duplicate entry names", e.getMessage());
1286                 }
1287         }
1288
1289         public void testInvalidTreeDuplicateNames3() {
1290                 final StringBuilder b = new StringBuilder();
1291                 entry(b, "100644 a");
1292                 entry(b, "40000 a");
1293                 final byte[] data = Constants.encodeASCII(b.toString());
1294                 try {
1295                         checker.checkTree(data);
1296                         fail("incorrectly accepted an invalid tree");
1297                 } catch (CorruptObjectException e) {
1298                         assertEquals("duplicate entry names", e.getMessage());
1299                 }
1300         }
1301
1302         public void testInvalidTreeDuplicateNames4() {
1303                 final StringBuilder b = new StringBuilder();
1304                 entry(b, "100644 a");
1305                 entry(b, "100644 a.c");
1306                 entry(b, "100644 a.d");
1307                 entry(b, "100644 a.e");
1308                 entry(b, "40000 a");
1309                 entry(b, "100644 zoo");
1310                 final byte[] data = Constants.encodeASCII(b.toString());
1311                 try {
1312                         checker.checkTree(data);
1313                         fail("incorrectly accepted an invalid tree");
1314                 } catch (CorruptObjectException e) {
1315                         assertEquals("duplicate entry names", e.getMessage());
1316                 }
1317         }
1318
1319         private static void entry(final StringBuilder b, final String modeName) {
1320                 b.append(modeName);
1321                 b.append('\0');
1322                 for (int i = 0; i < Constants.OBJECT_ID_LENGTH; i++)
1323                         b.append((char) i);
1324         }
1325 }