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