1
2
3
4
5
6
7
8
9
10
11 package org.eclipse.jgit.treewalk;
12
13 import static org.junit.Assert.assertEquals;
14 import static org.junit.Assert.assertFalse;
15 import static org.junit.Assert.assertTrue;
16
17 import org.eclipse.jgit.dircache.DirCache;
18 import org.eclipse.jgit.dircache.DirCacheBuilder;
19 import org.eclipse.jgit.dircache.DirCacheIterator;
20 import org.eclipse.jgit.junit.RepositoryTestCase;
21 import org.eclipse.jgit.lib.FileMode;
22 import org.junit.Test;
23
24 public class NameConflictTreeWalkTest extends RepositoryTestCase {
25 private static final FileMode TREE = FileMode.TREE;
26
27 private static final FileMode SYMLINK = FileMode.SYMLINK;
28
29 private static final FileMode MISSING = FileMode.MISSING;
30
31 private static final FileMode REGULAR_FILE = FileMode.REGULAR_FILE;
32
33 private static final FileMode EXECUTABLE_FILE = FileMode.EXECUTABLE_FILE;
34
35 @Test
36 public void testNoDF_NoGap() throws Exception {
37 final DirCache tree0 = db.readDirCache();
38 final DirCache tree1 = db.readDirCache();
39 {
40 final DirCacheBuilder b0 = tree0.builder();
41 final DirCacheBuilder b1 = tree1.builder();
42
43 b0.add(createEntry("a", REGULAR_FILE));
44 b0.add(createEntry("a.b", EXECUTABLE_FILE));
45 b1.add(createEntry("a/b", REGULAR_FILE));
46 b0.add(createEntry("a0b", SYMLINK));
47
48 b0.finish();
49 b1.finish();
50 assertEquals(3, tree0.getEntryCount());
51 assertEquals(1, tree1.getEntryCount());
52 }
53
54 try (TreeWalk tw = new TreeWalk(db)) {
55 tw.addTree(new DirCacheIterator(tree0));
56 tw.addTree(new DirCacheIterator(tree1));
57
58 assertModes("a", REGULAR_FILE, MISSING, tw);
59 assertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
60 assertModes("a", MISSING, TREE, tw);
61 tw.enterSubtree();
62 assertModes("a/b", MISSING, REGULAR_FILE, tw);
63 assertModes("a0b", SYMLINK, MISSING, tw);
64 }
65 }
66
67 @Test
68 public void testDF_NoGap() throws Exception {
69 final DirCache tree0 = db.readDirCache();
70 final DirCache tree1 = db.readDirCache();
71 {
72 final DirCacheBuilder b0 = tree0.builder();
73 final DirCacheBuilder b1 = tree1.builder();
74
75 b0.add(createEntry("a", REGULAR_FILE));
76 b0.add(createEntry("a.b", EXECUTABLE_FILE));
77 b1.add(createEntry("a/b", REGULAR_FILE));
78 b0.add(createEntry("a0b", SYMLINK));
79
80 b0.finish();
81 b1.finish();
82 assertEquals(3, tree0.getEntryCount());
83 assertEquals(1, tree1.getEntryCount());
84 }
85
86 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
87 tw.addTree(new DirCacheIterator(tree0));
88 tw.addTree(new DirCacheIterator(tree1));
89
90 assertModes("a", REGULAR_FILE, TREE, tw);
91 assertTrue(tw.isDirectoryFileConflict());
92 assertTrue(tw.isSubtree());
93 tw.enterSubtree();
94 assertModes("a/b", MISSING, REGULAR_FILE, tw);
95 assertTrue(tw.isDirectoryFileConflict());
96 assertModes("a.b", EXECUTABLE_FILE, MISSING, tw);
97 assertFalse(tw.isDirectoryFileConflict());
98 assertModes("a0b", SYMLINK, MISSING, tw);
99 assertFalse(tw.isDirectoryFileConflict());
100 }
101 }
102
103 @Test
104 public void testDF_GapByOne() throws Exception {
105 final DirCache tree0 = db.readDirCache();
106 final DirCache tree1 = db.readDirCache();
107 {
108 final DirCacheBuilder b0 = tree0.builder();
109 final DirCacheBuilder b1 = tree1.builder();
110
111 b0.add(createEntry("a", REGULAR_FILE));
112 b0.add(createEntry("a.b", EXECUTABLE_FILE));
113 b1.add(createEntry("a.b", EXECUTABLE_FILE));
114 b1.add(createEntry("a/b", REGULAR_FILE));
115 b0.add(createEntry("a0b", SYMLINK));
116
117 b0.finish();
118 b1.finish();
119 assertEquals(3, tree0.getEntryCount());
120 assertEquals(2, tree1.getEntryCount());
121 }
122
123 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
124 tw.addTree(new DirCacheIterator(tree0));
125 tw.addTree(new DirCacheIterator(tree1));
126
127 assertModes("a", REGULAR_FILE, TREE, tw);
128 assertTrue(tw.isSubtree());
129 assertTrue(tw.isDirectoryFileConflict());
130 tw.enterSubtree();
131 assertModes("a/b", MISSING, REGULAR_FILE, tw);
132 assertTrue(tw.isDirectoryFileConflict());
133 assertModes("a.b", EXECUTABLE_FILE, EXECUTABLE_FILE, tw);
134 assertFalse(tw.isDirectoryFileConflict());
135 assertModes("a0b", SYMLINK, MISSING, tw);
136 assertFalse(tw.isDirectoryFileConflict());
137 }
138 }
139
140 @Test
141 public void testDF_specialFileNames() throws Exception {
142 final DirCache tree0 = db.readDirCache();
143 final DirCache tree1 = db.readDirCache();
144 final DirCache tree2 = db.readDirCache();
145 {
146 final DirCacheBuilder b0 = tree0.builder();
147 final DirCacheBuilder b1 = tree1.builder();
148 final DirCacheBuilder b2 = tree2.builder();
149
150 b0.add(createEntry("gradle.properties", REGULAR_FILE));
151 b0.add(createEntry("gradle/nested_file.txt", REGULAR_FILE));
152
153 b1.add(createEntry("gradle.properties", REGULAR_FILE));
154
155 b2.add(createEntry("gradle", REGULAR_FILE));
156 b2.add(createEntry("gradle.properties", REGULAR_FILE));
157
158 b0.finish();
159 b1.finish();
160 b2.finish();
161 assertEquals(2, tree0.getEntryCount());
162 assertEquals(1, tree1.getEntryCount());
163 assertEquals(2, tree2.getEntryCount());
164 }
165
166 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
167 tw.addTree(new DirCacheIterator(tree0));
168 tw.addTree(new DirCacheIterator(tree1));
169 tw.addTree(new DirCacheIterator(tree2));
170
171 assertModes("gradle", TREE, MISSING, REGULAR_FILE, tw);
172 assertTrue(tw.isSubtree());
173 assertTrue(tw.isDirectoryFileConflict());
174 tw.enterSubtree();
175 assertModes("gradle/nested_file.txt", REGULAR_FILE, MISSING,
176 MISSING, tw);
177 assertFalse(tw.isSubtree());
178
179
180 assertTrue(tw.isDirectoryFileConflict());
181 assertModes("gradle.properties", REGULAR_FILE, REGULAR_FILE,
182 REGULAR_FILE, tw);
183 assertFalse(tw.isSubtree());
184 assertFalse(tw.isDirectoryFileConflict());
185 }
186 }
187
188 @Test
189 public void testDF_SkipsSeenSubtree() throws Exception {
190 final DirCache tree0 = db.readDirCache();
191 final DirCache tree1 = db.readDirCache();
192 {
193 final DirCacheBuilder b0 = tree0.builder();
194 final DirCacheBuilder b1 = tree1.builder();
195
196 b0.add(createEntry("a", REGULAR_FILE));
197 b1.add(createEntry("a.b", EXECUTABLE_FILE));
198 b1.add(createEntry("a/b", REGULAR_FILE));
199 b0.add(createEntry("a0b", SYMLINK));
200 b1.add(createEntry("a0b", SYMLINK));
201
202 b0.finish();
203 b1.finish();
204 assertEquals(2, tree0.getEntryCount());
205 assertEquals(3, tree1.getEntryCount());
206 }
207
208 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
209 tw.addTree(new DirCacheIterator(tree0));
210 tw.addTree(new DirCacheIterator(tree1));
211
212 assertModes("a", REGULAR_FILE, TREE, tw);
213 assertTrue(tw.isSubtree());
214 assertTrue(tw.isDirectoryFileConflict());
215 tw.enterSubtree();
216 assertModes("a/b", MISSING, REGULAR_FILE, tw);
217 assertTrue(tw.isDirectoryFileConflict());
218 assertModes("a.b", MISSING, EXECUTABLE_FILE, tw);
219 assertFalse(tw.isDirectoryFileConflict());
220 assertModes("a0b", SYMLINK, SYMLINK, tw);
221 assertFalse(tw.isDirectoryFileConflict());
222 }
223 }
224
225 @Test
226 public void testDF_DetectConflict() throws Exception {
227 final DirCache tree0 = db.readDirCache();
228 final DirCache tree1 = db.readDirCache();
229 {
230 final DirCacheBuilder b0 = tree0.builder();
231 final DirCacheBuilder b1 = tree1.builder();
232
233 b0.add(createEntry("0", REGULAR_FILE));
234 b0.add(createEntry("a", REGULAR_FILE));
235 b1.add(createEntry("0", REGULAR_FILE));
236 b1.add(createEntry("a.b", REGULAR_FILE));
237 b1.add(createEntry("a/b", REGULAR_FILE));
238 b1.add(createEntry("a/c/e", REGULAR_FILE));
239
240 b0.finish();
241 b1.finish();
242 assertEquals(2, tree0.getEntryCount());
243 assertEquals(4, tree1.getEntryCount());
244 }
245
246 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
247 tw.addTree(new DirCacheIterator(tree0));
248 tw.addTree(new DirCacheIterator(tree1));
249
250 assertModes("0", REGULAR_FILE, REGULAR_FILE, tw);
251 assertFalse(tw.isDirectoryFileConflict());
252 assertModes("a", REGULAR_FILE, TREE, tw);
253 assertTrue(tw.isSubtree());
254 assertTrue(tw.isDirectoryFileConflict());
255 tw.enterSubtree();
256 assertModes("a/b", MISSING, REGULAR_FILE, tw);
257 assertTrue(tw.isDirectoryFileConflict());
258 assertModes("a/c", MISSING, TREE, tw);
259 assertTrue(tw.isDirectoryFileConflict());
260 tw.enterSubtree();
261 assertModes("a/c/e", MISSING, REGULAR_FILE, tw);
262 assertTrue(tw.isDirectoryFileConflict());
263
264 assertModes("a.b", MISSING, REGULAR_FILE, tw);
265 assertFalse(tw.isDirectoryFileConflict());
266 }
267 }
268
269 private static void assertModes(String path, FileMode mode0, FileMode mode1,
270 TreeWalk tw) throws Exception {
271 assertTrue("has " + path, tw.next());
272 assertEquals(path, tw.getPathString());
273 assertEquals(mode0, tw.getFileMode(0));
274 assertEquals(mode1, tw.getFileMode(1));
275 }
276
277 private static void assertModes(String path, FileMode mode0, FileMode mode1,
278 FileMode mode2, TreeWalk tw) throws Exception {
279 assertTrue("has " + path, tw.next());
280 assertEquals(path, tw.getPathString());
281 if (tw.getFileMode(0) != FileMode.MISSING) {
282 assertEquals(path, TreeWalk.pathOf(tw.trees[0]));
283 }
284 if (tw.getFileMode(1) != FileMode.MISSING) {
285 assertEquals(path, TreeWalk.pathOf(tw.trees[1]));
286 }
287 if (tw.getFileMode(2) != FileMode.MISSING) {
288 assertEquals(path, TreeWalk.pathOf(tw.trees[2]));
289 }
290 assertEquals(mode0, tw.getFileMode(0));
291 assertEquals(mode1, tw.getFileMode(1));
292 assertEquals(mode2, tw.getFileMode(2));
293 }
294 }