Add test with untracked folders to IndexDiffCacheTest

In I5cd27f79606decca73b7a0977d147c97e06bfaba, this will be a problematic
case. Now it succeeds because an index diff change triggers a full
refresh each time.

Change-Id: I334c16b202966084cf310fd0a61cad59f34f8ecd
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

1 files changed, 60 insertions, 25 deletions

diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/indexDiff/IndexDiffCacheTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/indexDiff/IndexDiffCacheTest.java
index 4c2a52c9e0..a191efcae2 100644
--- a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/indexDiff/IndexDiffCacheTest.java
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/test/indexDiff/IndexDiffCacheTest.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2011, Jens Baumgart <jens.baumgart@sap.com>
+ * Copyright (C) 2011, 2012 Jens Baumgart <jens.baumgart@sap.com> and others.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
@@ -8,12 +8,16 @@
  *******************************************************************************/
 package org.eclipse.egit.core.test.indexDiff;
 
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.Matchers.hasItem;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.eclipse.core.resources.IFile;
 import org.eclipse.egit.core.Activator;
 import org.eclipse.egit.core.internal.indexdiff.IndexDiffCache;
 import org.eclipse.egit.core.internal.indexdiff.IndexDiffCacheEntry;
@@ -35,6 +39,10 @@ public class IndexDiffCacheTest extends GitTestCase {
 
 	Repository repository;
 
+	private AtomicBoolean listenerCalled;
+
+	private AtomicReference<IndexDiffData> indexDiffDataResult;
+
 	@Before
 	public void setUp() throws Exception {
 		super.setUp();
@@ -56,28 +64,13 @@ public class IndexDiffCacheTest extends GitTestCase {
 		// create first commit containing a dummy file
 		testRepository
 				.createInitialCommit("testBranchOperation\n\nfirst commit\n");
-		IndexDiffCache indexDiffCache = Activator.getDefault()
-				.getIndexDiffCache();
-		// This call should trigger an indexDiffChanged event
-		IndexDiffCacheEntry cacheEntry = indexDiffCache
-				.getIndexDiffCacheEntry(repository);
-		final AtomicBoolean listenerCalled = new AtomicBoolean(false);
-		final AtomicReference<IndexDiffData> resultDiff = new AtomicReference<IndexDiffData>(
-				null);
-		cacheEntry.addIndexDiffChangedListener(new IndexDiffChangedListener() {
-			public void indexDiffChanged(Repository repo,
-					IndexDiffData indexDiffData) {
-				listenerCalled.set(true);
-				resultDiff.set(indexDiffData);
-			}
-		});
-		waitForListenerCalled(listenerCalled);
+		prepareCacheEntry();
+		waitForListenerCalled();
 		final String fileName = "aFile";
 		// This call should trigger an indexDiffChanged event (triggered via
 		// resource changed event)
 		project.createFile(fileName, "content".getBytes("UTF-8"));
-		waitForListenerCalled(listenerCalled);
-		IndexDiffData indexDiffData = resultDiff.get();
+		IndexDiffData indexDiffData = waitForListenerCalled();
 		String path = project.project.getFile(fileName).getFullPath()
 				.toString().substring(1);
 		if (!indexDiffData.getUntracked().contains(path))
@@ -85,16 +78,57 @@ public class IndexDiffCacheTest extends GitTestCase {
 		new Git(repository).add().addFilepattern(path).call();
 		// This call should trigger an indexDiffChanged event
 		repository.fireEvent(new IndexChangedEvent());
-		waitForListenerCalled(listenerCalled);
-		indexDiffData = resultDiff.get();
-		if (indexDiffData.getUntracked().contains(path))
+		IndexDiffData indexDiffData2 = waitForListenerCalled();
+		if (indexDiffData2.getUntracked().contains(path))
 			fail("IndexDiffData contains aFile as untracked");
-		if (!indexDiffData.getAdded().contains(path))
+		if (!indexDiffData2.getAdded().contains(path))
 			fail("IndexDiffData does not contain aFile as added");
 	}
 
-	private void waitForListenerCalled(final AtomicBoolean listenerCalled)
-			throws InterruptedException {
+	@Test
+	public void testAddFileFromUntrackedFolder() throws Exception {
+		testRepository.connect(project.project);
+		testRepository.addToIndex(project.project);
+		testRepository.createInitialCommit("testAddFileFromUntrackedFolder\n\nfirst commit\n");
+		prepareCacheEntry();
+
+		project.createFolder("folder");
+		project.createFolder("folder/a");
+		project.createFolder("folder/b");
+		IFile fileA = project.createFile("folder/a/file", new byte[] {});
+		project.createFile("folder/b/file", new byte[] {});
+
+		IndexDiffData data1 = waitForListenerCalled();
+		assertThat(data1.getUntrackedFolders(), hasItem("Project-1/folder/"));
+
+		testRepository.track(fileA.getLocation().toFile());
+
+		IndexDiffData data2 = waitForListenerCalled();
+		assertThat(data2.getAdded(), hasItem("Project-1/folder/a/file"));
+		assertThat(data2.getUntrackedFolders(), not(hasItem("Project-1/folder/")));
+		assertThat(data2.getUntrackedFolders(), not(hasItem("Project-1/folder/a")));
+		assertThat(data2.getUntrackedFolders(), hasItem("Project-1/folder/b/"));
+	}
+
+	private void prepareCacheEntry() {
+		IndexDiffCache indexDiffCache = Activator.getDefault()
+				.getIndexDiffCache();
+		// This call should trigger an indexDiffChanged event
+		IndexDiffCacheEntry cacheEntry = indexDiffCache
+				.getIndexDiffCacheEntry(repository);
+		listenerCalled = new AtomicBoolean(false);
+		indexDiffDataResult = new AtomicReference<IndexDiffData>(
+				null);
+		cacheEntry.addIndexDiffChangedListener(new IndexDiffChangedListener() {
+			public void indexDiffChanged(Repository repo,
+					IndexDiffData indexDiffData) {
+				listenerCalled.set(true);
+				indexDiffDataResult.set(indexDiffData);
+			}
+		});
+	}
+
+	private IndexDiffData waitForListenerCalled() throws InterruptedException {
 		long time = 0;
 		while (!listenerCalled.get() && time < 10000) {
 			Thread.sleep(1);
@@ -102,6 +136,7 @@ public class IndexDiffCacheTest extends GitTestCase {
 		}
 		assertTrue("indexDiffChanged was not called", listenerCalled.get());
 		listenerCalled.set(false);
+		return indexDiffDataResult.get();
 	}
 
 }