org.spearce.jgit.test/tst/org/spearce/jgit/dircache/DirCacheIteratorTest.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
  38 package org.spearce.jgit.dircache;
  39
  40 import java.util.Collections;
  41
  42 import org.spearce.jgit.lib.FileMode;
  43 import org.spearce.jgit.lib.RepositoryTestCase;
  44 import org.spearce.jgit.treewalk.TreeWalk;
  45 import org.spearce.jgit.treewalk.filter.PathFilterGroup;
  46
  47 public class DirCacheIteratorTest extends RepositoryTestCase {
  48         public void testEmptyTree_NoTreeWalk() throws Exception {
  49                 final DirCache dc = DirCache.read(db);
  50                 assertEquals(0, dc.getEntryCount());
  51
  52                 final DirCacheIterator i = new DirCacheIterator(dc);
  53                 i.next();
  54                 assertTrue(i.eof());
  55         }
  56
  57         public void testEmptyTree_WithTreeWalk() throws Exception {
  58                 final DirCache dc = DirCache.read(db);
  59                 assertEquals(0, dc.getEntryCount());
  60
  61                 final TreeWalk tw = new TreeWalk(db);
  62                 tw.reset();
  63                 tw.addTree(new DirCacheIterator(dc));
  64                 assertFalse(tw.next());
  65         }
  66
  67         public void testNoSubtree_NoTreeWalk() throws Exception {
  68                 final DirCache dc = DirCache.read(db);
  69
  70                 final String[] paths = { "a.", "a0b" };
  71                 final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
  72                 for (int i = 0; i < paths.length; i++)
  73                         ents[i] = new DirCacheEntry(paths[i]);
  74
  75                 final DirCacheBuilder b = dc.builder();
  76                 for (int i = 0; i < ents.length; i++)
  77                         b.add(ents[i]);
  78                 b.finish();
  79
  80                 final DirCacheIterator i = new DirCacheIterator(dc);
  81                 int pathIdx = 0;
  82                 for (;;) {
  83                         i.next();
  84                         if (i.eof())
  85                                 break;
  86                         assertEquals(pathIdx, i.cachePos);
  87                         assertSame(ents[pathIdx], i.getDirCacheEntry());
  88                         pathIdx++;
  89                 }
  90                 assertEquals(paths.length, pathIdx);
  91         }
  92
  93         public void testNoSubtree_WithTreeWalk() throws Exception {
  94                 final DirCache dc = DirCache.read(db);
  95
  96                 final String[] paths = { "a.", "a0b" };
  97                 final FileMode[] modes = { FileMode.EXECUTABLE_FILE, FileMode.GITLINK };
  98                 final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
  99                 for (int i = 0; i < paths.length; i++) {
 100                         ents[i] = new DirCacheEntry(paths[i]);
 101                         ents[i].setFileMode(modes[i]);
 102                 }
 103
 104                 final DirCacheBuilder b = dc.builder();
 105                 for (int i = 0; i < ents.length; i++)
 106                         b.add(ents[i]);
 107                 b.finish();
 108
 109                 final DirCacheIterator i = new DirCacheIterator(dc);
 110                 final TreeWalk tw = new TreeWalk(db);
 111                 tw.reset();
 112                 tw.addTree(i);
 113                 int pathIdx = 0;
 114                 while (tw.next()) {
 115                         assertSame(i, tw.getTree(0, DirCacheIterator.class));
 116                         assertEquals(pathIdx, i.cachePos);
 117                         assertSame(ents[pathIdx], i.getDirCacheEntry());
 118                         assertEquals(paths[pathIdx], tw.getPathString());
 119                         assertEquals(modes[pathIdx].getBits(), tw.getRawMode(0));
 120                         assertSame(modes[pathIdx], tw.getFileMode(0));
 121                         pathIdx++;
 122                 }
 123                 assertEquals(paths.length, pathIdx);
 124         }
 125
 126         public void testSingleSubtree_NoRecursion() throws Exception {
 127                 final DirCache dc = DirCache.read(db);
 128
 129                 final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
 130                 final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
 131                 for (int i = 0; i < paths.length; i++) {
 132                         ents[i] = new DirCacheEntry(paths[i]);
 133                         ents[i].setFileMode(FileMode.REGULAR_FILE);
 134                 }
 135
 136                 final DirCacheBuilder b = dc.builder();
 137                 for (int i = 0; i < ents.length; i++)
 138                         b.add(ents[i]);
 139                 b.finish();
 140
 141                 final String[] expPaths = { "a.", "a", "a0b" };
 142                 final FileMode[] expModes = { FileMode.REGULAR_FILE, FileMode.TREE,
 143                                 FileMode.REGULAR_FILE };
 144                 final int expPos[] = { 0, -1, 4 };
 145
 146                 final DirCacheIterator i = new DirCacheIterator(dc);
 147                 final TreeWalk tw = new TreeWalk(db);
 148                 tw.reset();
 149                 tw.addTree(i);
 150                 tw.setRecursive(false);
 151                 int pathIdx = 0;
 152                 while (tw.next()) {
 153                         assertSame(i, tw.getTree(0, DirCacheIterator.class));
 154                         assertEquals(expModes[pathIdx].getBits(), tw.getRawMode(0));
 155                         assertSame(expModes[pathIdx], tw.getFileMode(0));
 156                         assertEquals(expPaths[pathIdx], tw.getPathString());
 157
 158                         if (expPos[pathIdx] >= 0) {
 159                                 assertEquals(expPos[pathIdx], i.cachePos);
 160                                 assertSame(ents[expPos[pathIdx]], i.getDirCacheEntry());
 161                         } else {
 162                                 assertSame(FileMode.TREE, tw.getFileMode(0));
 163                         }
 164
 165                         pathIdx++;
 166                 }
 167                 assertEquals(expPaths.length, pathIdx);
 168         }
 169
 170         public void testSingleSubtree_Recursive() throws Exception {
 171                 final DirCache dc = DirCache.read(db);
 172
 173                 final FileMode mode = FileMode.REGULAR_FILE;
 174                 final String[] paths = { "a.", "a/b", "a/c", "a/d", "a0b" };
 175                 final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
 176                 for (int i = 0; i < paths.length; i++) {
 177                         ents[i] = new DirCacheEntry(paths[i]);
 178                         ents[i].setFileMode(mode);
 179                 }
 180
 181                 final DirCacheBuilder b = dc.builder();
 182                 for (int i = 0; i < ents.length; i++)
 183                         b.add(ents[i]);
 184                 b.finish();
 185
 186                 final DirCacheIterator i = new DirCacheIterator(dc);
 187                 final TreeWalk tw = new TreeWalk(db);
 188                 tw.reset();
 189                 tw.addTree(i);
 190                 tw.setRecursive(true);
 191                 int pathIdx = 0;
 192                 while (tw.next()) {
 193                         final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
 194                         assertNotNull(c);
 195                         assertEquals(pathIdx, c.cachePos);
 196                         assertSame(ents[pathIdx], c.getDirCacheEntry());
 197                         assertEquals(paths[pathIdx], tw.getPathString());
 198                         assertEquals(mode.getBits(), tw.getRawMode(0));
 199                         assertSame(mode, tw.getFileMode(0));
 200                         pathIdx++;
 201                 }
 202                 assertEquals(paths.length, pathIdx);
 203         }
 204
 205         public void testTwoLevelSubtree_Recursive() throws Exception {
 206                 final DirCache dc = DirCache.read(db);
 207
 208                 final FileMode mode = FileMode.REGULAR_FILE;
 209                 final String[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
 210                 final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
 211                 for (int i = 0; i < paths.length; i++) {
 212                         ents[i] = new DirCacheEntry(paths[i]);
 213                         ents[i].setFileMode(mode);
 214                 }
 215
 216                 final DirCacheBuilder b = dc.builder();
 217                 for (int i = 0; i < ents.length; i++)
 218                         b.add(ents[i]);
 219                 b.finish();
 220
 221                 final TreeWalk tw = new TreeWalk(db);
 222                 tw.reset();
 223                 tw.addTree(new DirCacheIterator(dc));
 224                 tw.setRecursive(true);
 225                 int pathIdx = 0;
 226                 while (tw.next()) {
 227                         final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
 228                         assertNotNull(c);
 229                         assertEquals(pathIdx, c.cachePos);
 230                         assertSame(ents[pathIdx], c.getDirCacheEntry());
 231                         assertEquals(paths[pathIdx], tw.getPathString());
 232                         assertEquals(mode.getBits(), tw.getRawMode(0));
 233                         assertSame(mode, tw.getFileMode(0));
 234                         pathIdx++;
 235                 }
 236                 assertEquals(paths.length, pathIdx);
 237         }
 238
 239         public void testTwoLevelSubtree_FilterPath() throws Exception {
 240                 final DirCache dc = DirCache.read(db);
 241
 242                 final FileMode mode = FileMode.REGULAR_FILE;
 243                 final String[] paths = { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
 244                 final DirCacheEntry[] ents = new DirCacheEntry[paths.length];
 245                 for (int i = 0; i < paths.length; i++) {
 246                         ents[i] = new DirCacheEntry(paths[i]);
 247                         ents[i].setFileMode(mode);
 248                 }
 249
 250                 final DirCacheBuilder b = dc.builder();
 251                 for (int i = 0; i < ents.length; i++)
 252                         b.add(ents[i]);
 253                 b.finish();
 254
 255                 final TreeWalk tw = new TreeWalk(db);
 256                 for (int victimIdx = 0; victimIdx < paths.length; victimIdx++) {
 257                         tw.reset();
 258                         tw.addTree(new DirCacheIterator(dc));
 259                         tw.setFilter(PathFilterGroup.createFromStrings(Collections
 260                                         .singleton(paths[victimIdx])));
 261                         tw.setRecursive(tw.getFilter().shouldBeRecursive());
 262                         assertTrue(tw.next());
 263                         final DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
 264                         assertNotNull(c);
 265                         assertEquals(victimIdx, c.cachePos);
 266                         assertSame(ents[victimIdx], c.getDirCacheEntry());
 267                         assertEquals(paths[victimIdx], tw.getPathString());
 268                         assertEquals(mode.getBits(), tw.getRawMode(0));
 269                         assertSame(mode, tw.getFileMode(0));
 270                         assertFalse(tw.next());
 271                 }
 272         }
 273 }