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_SkipsSeenSubtree() throws Exception {
142 final DirCache tree0 = db.readDirCache();
143 final DirCache tree1 = db.readDirCache();
144 {
145 final DirCacheBuilder b0 = tree0.builder();
146 final DirCacheBuilder b1 = tree1.builder();
147
148 b0.add(createEntry("a", REGULAR_FILE));
149 b1.add(createEntry("a.b", EXECUTABLE_FILE));
150 b1.add(createEntry("a/b", REGULAR_FILE));
151 b0.add(createEntry("a0b", SYMLINK));
152 b1.add(createEntry("a0b", SYMLINK));
153
154 b0.finish();
155 b1.finish();
156 assertEquals(2, tree0.getEntryCount());
157 assertEquals(3, tree1.getEntryCount());
158 }
159
160 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
161 tw.addTree(new DirCacheIterator(tree0));
162 tw.addTree(new DirCacheIterator(tree1));
163
164 assertModes("a", REGULAR_FILE, TREE, tw);
165 assertTrue(tw.isSubtree());
166 assertTrue(tw.isDirectoryFileConflict());
167 tw.enterSubtree();
168 assertModes("a/b", MISSING, REGULAR_FILE, tw);
169 assertTrue(tw.isDirectoryFileConflict());
170 assertModes("a.b", MISSING, EXECUTABLE_FILE, tw);
171 assertFalse(tw.isDirectoryFileConflict());
172 assertModes("a0b", SYMLINK, SYMLINK, tw);
173 assertFalse(tw.isDirectoryFileConflict());
174 }
175 }
176
177 @Test
178 public void testDF_DetectConflict() throws Exception {
179 final DirCache tree0 = db.readDirCache();
180 final DirCache tree1 = db.readDirCache();
181 {
182 final DirCacheBuilder b0 = tree0.builder();
183 final DirCacheBuilder b1 = tree1.builder();
184
185 b0.add(createEntry("0", REGULAR_FILE));
186 b0.add(createEntry("a", REGULAR_FILE));
187 b1.add(createEntry("0", REGULAR_FILE));
188 b1.add(createEntry("a.b", REGULAR_FILE));
189 b1.add(createEntry("a/b", REGULAR_FILE));
190 b1.add(createEntry("a/c/e", REGULAR_FILE));
191
192 b0.finish();
193 b1.finish();
194 assertEquals(2, tree0.getEntryCount());
195 assertEquals(4, tree1.getEntryCount());
196 }
197
198 try (NameConflictTreeWalk tw = new NameConflictTreeWalk(db)) {
199 tw.addTree(new DirCacheIterator(tree0));
200 tw.addTree(new DirCacheIterator(tree1));
201
202 assertModes("0", REGULAR_FILE, REGULAR_FILE, tw);
203 assertFalse(tw.isDirectoryFileConflict());
204 assertModes("a", REGULAR_FILE, TREE, tw);
205 assertTrue(tw.isSubtree());
206 assertTrue(tw.isDirectoryFileConflict());
207 tw.enterSubtree();
208 assertModes("a/b", MISSING, REGULAR_FILE, tw);
209 assertTrue(tw.isDirectoryFileConflict());
210 assertModes("a/c", MISSING, TREE, tw);
211 assertTrue(tw.isDirectoryFileConflict());
212 tw.enterSubtree();
213 assertModes("a/c/e", MISSING, REGULAR_FILE, tw);
214 assertTrue(tw.isDirectoryFileConflict());
215
216 assertModes("a.b", MISSING, REGULAR_FILE, tw);
217 assertFalse(tw.isDirectoryFileConflict());
218 }
219 }
220
221 private static void assertModes(final String path, final FileMode mode0,
222 final FileMode mode1, final TreeWalk tw) throws Exception {
223 assertTrue("has " + path, tw.next());
224 assertEquals(path, tw.getPathString());
225 assertEquals(mode0, tw.getFileMode(0));
226 assertEquals(mode1, tw.getFileMode(1));
227 }
228 }