Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMatthias Sohn2015-02-04 13:22:30 +0000
committerMatthias Sohn2015-02-04 13:22:59 +0000
commit8b6df73a9b04f5fa3acfc46d7341536ee09b3998 (patch)
treeab6520b9e1779c5e2f2506555c2d61375d8021ea /org.eclipse.egit.core.test
parentcfab4bc2c7469ec78c0d7dc11681f02b1b081b64 (diff)
parentd9754134f067f1617ec419ada7c40a1c58af42ec (diff)
downloadegit-8b6df73a9b04f5fa3acfc46d7341536ee09b3998.tar.gz
egit-8b6df73a9b04f5fa3acfc46d7341536ee09b3998.tar.xz
egit-8b6df73a9b04f5fa3acfc46d7341536ee09b3998.zip
Merge branch 'stable-3.7'
* stable-3.7: Prepare post 3.7.0.201502031740-rc1 builds EGit v3.7.0.201502031740-rc1 Lookup active window before opening commit selection dialog [stagingview] "Updating index" should indicate that view is "busy" [stagingview] "Refresh" operation should indicate that view is "busy" Update readme to describe current state of symlink support Let staging view use submodule repos UI Activator: allow tracing if workbench UI is active Jobs should not unnecessarily lock the workspace Open mergetool by default in staging view when in conflicting state Don't run "Compare with previous" in UI thread Implement hasChildren() to avoid diff calculation in UI thread Don't run indexDiff.diff() in UI thread Always run compare input calculation in background thread Scalability: don't run incremental update if there are too many changes Change-Id: I5452a465bb4b2bbd988f5f11fd4bf395ee875272 Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
Diffstat (limited to 'org.eclipse.egit.core.test')
-rw-r--r--org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java258
-rw-r--r--org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java88
2 files changed, 346 insertions, 0 deletions
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java
new file mode 100644
index 0000000000..650abf5d0e
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffCacheEntryTest.java
@@ -0,0 +1,258 @@
+/*******************************************************************************
+ * Copyright (C) 2015 Andrey Loskutov <loskutov@gmx.de> and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.internal.indexdiff;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRunnable;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.jobs.IJobManager;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.JobFamilies;
+import org.eclipse.egit.core.test.GitTestCase;
+import org.eclipse.egit.core.test.TestRepository;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class IndexDiffCacheEntryTest extends GitTestCase {
+
+ // trigger reload if more than one file is changed
+ private static final int MAX_FILES_FOR_UPDATE = 1;
+
+ private static final int MAX_WAIT_TIME = 10 * 1000;
+
+
+ private TestRepository testRepository;
+
+ private Repository repository;
+
+ private IndexDiffCacheEntry2 entry;
+
+ @Test
+ public void basicTest() throws Exception {
+ prepareCacheEntry();
+
+ entry.refresh();
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // on refresh, full reload is triggered
+ assertTrue(entry.reloadScheduled);
+ assertFalse(entry.updateScheduled);
+ cleanEntryFlags();
+
+ entry.refreshFiles(Arrays.asList("a"));
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // one single file: no reload
+ assertFalse(entry.reloadScheduled);
+ assertTrue(entry.updateScheduled);
+ cleanEntryFlags();
+
+ entry.refreshFiles(Arrays.asList("a", "b"));
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // two files: update is triggered, but decides to run full reload
+ assertTrue(entry.reloadScheduled);
+ assertTrue(entry.updateScheduled);
+ cleanEntryFlags();
+
+ entry.getUpdateJob().addChanges(Arrays.asList("a", "b"),
+ Collections.<IResource> emptyList());
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // two files: update is not triggered (we call through the job directly)
+ // but this calls full reload
+ assertTrue(entry.reloadScheduled);
+ assertFalse(entry.updateScheduled);
+ cleanEntryFlags();
+ }
+
+ @Test
+ public void testReloadAndUpdate() throws Exception {
+ prepareCacheEntry();
+
+ testRepository.connect(project.project);
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // on a simple connect, nothing should be called
+ assertFalse(entry.reloadScheduled);
+ assertFalse(entry.updateScheduled);
+ cleanEntryFlags();
+
+ // adds .project and .classpath files: more than limit of 1,
+ // so update redirects to reload
+ testRepository.addToIndex(project.project);
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ assertTrue(entry.reloadScheduled);
+ assertTrue(entry.updateScheduled);
+ cleanEntryFlags();
+
+ testRepository.createInitialCommit("first commit\n");
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // RefsChangedEvent causes always full update
+ assertTrue(entry.reloadScheduled);
+ // single "dummy" file from commit
+ assertTrue(entry.updateScheduled);
+ cleanEntryFlags();
+
+ ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+ public void run(IProgressMonitor monitor) throws CoreException {
+ try {
+ project.createFile("bla", "bla\n".getBytes("UTF-8"));
+ project.createFile("blup", "blup\n".getBytes("UTF-8"));
+ } catch (Exception e) {
+ throw new CoreException(Activator.error("Failure", e));
+ }
+
+ }
+ }, null);
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // adds 2 files: more than limit of 1,
+ // so update redirects to reload
+ assertTrue(entry.reloadScheduled);
+ assertTrue(entry.updateScheduled);
+ cleanEntryFlags();
+
+ ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+ public void run(IProgressMonitor monitor) throws CoreException {
+ try {
+ project.createFile("blip", "blip\n".getBytes("UTF-8"));
+ } catch (Exception e) {
+ throw new CoreException(Activator.error("Failure", e));
+ }
+
+ }
+ }, null);
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // adds 1 file: less than limit of 1, so no reload
+ assertFalse(entry.reloadScheduled);
+ assertTrue(entry.updateScheduled);
+ cleanEntryFlags();
+
+ ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
+ public void run(IProgressMonitor monitor) throws CoreException {
+ try {
+ project.createFile(".gitignore", "\n".getBytes("UTF-8"));
+ } catch (Exception e) {
+ throw new CoreException(Activator.error("Failure", e));
+ }
+
+ }
+ }, null);
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // adds .gitignore file: always full reload
+ assertTrue(entry.reloadScheduled);
+ assertFalse(entry.updateScheduled);
+ cleanEntryFlags();
+ }
+
+ /**
+ * Waits at least 50 milliseconds until no jobs of given family are running
+ *
+ * @param maxWaitTime
+ * @param family
+ * @throws InterruptedException
+ */
+ private void waitForJobs(long maxWaitTime, Object family)
+ throws InterruptedException {
+ Thread.sleep(50);
+ long start = System.currentTimeMillis();
+ IJobManager jobManager = Job.getJobManager();
+
+ Job[] jobs = jobManager.find(family);
+ while (jobs.length > 0) {
+ Thread.sleep(100);
+ jobs = jobManager.find(family);
+ if (System.currentTimeMillis() - start > maxWaitTime) {
+ return;
+ }
+ }
+ }
+
+ private void cleanEntryFlags() {
+ entry.reloadScheduled = false;
+ entry.updateScheduled = false;
+ }
+
+ private IndexDiffCacheEntry2 prepareCacheEntry() throws Exception {
+ entry = new IndexDiffCacheEntry2(repository);
+ waitForJobs(MAX_WAIT_TIME, JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+
+ // on creation, full reload is triggered
+ assertTrue(entry.reloadScheduled);
+ assertFalse(entry.updateScheduled);
+ cleanEntryFlags();
+ return entry;
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ testRepository = new TestRepository(gitDir);
+ repository = testRepository.getRepository();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ entry.dispose();
+ testRepository.dispose();
+ repository = null;
+ super.tearDown();
+ }
+
+ class IndexDiffCacheEntry2 extends IndexDiffCacheEntry {
+
+ boolean reloadScheduled;
+
+ boolean updateScheduled;
+
+ public IndexDiffCacheEntry2(Repository repository) {
+ super(repository);
+ }
+
+ @Override
+ protected void scheduleReloadJob(String trigger) {
+ reloadScheduled = true;
+ super.scheduleReloadJob(trigger);
+ }
+
+ @Override
+ protected void scheduleUpdateJob(Collection<String> filesToUpdate,
+ Collection<IResource> resourcesToUpdate) {
+ updateScheduled = true;
+ super.scheduleUpdateJob(filesToUpdate, resourcesToUpdate);
+ }
+
+ @Override
+ protected boolean shouldReload(Collection<String> filesToUpdate) {
+ return filesToUpdate.size() > MAX_FILES_FOR_UPDATE;
+ }
+
+ public IndexDiffUpdateJob getUpdateJob() {
+ return super.getUpdateJob();
+ }
+ }
+
+}
diff --git a/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java
new file mode 100644
index 0000000000..3e3886804a
--- /dev/null
+++ b/org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/indexdiff/IndexDiffDataTest.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (C) 2015 Andrey Loskutov <loskutov@gmx.de> and others.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *******************************************************************************/
+package org.eclipse.egit.core.internal.indexdiff;
+
+import static java.util.Arrays.asList;
+import static org.eclipse.egit.core.internal.indexdiff.IndexDiffData.isAnyPrefixOf;
+import static org.eclipse.egit.core.internal.indexdiff.IndexDiffData.mergeIgnored;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.egit.core.test.GitTestCase;
+import org.junit.Test;
+
+public class IndexDiffDataTest extends GitTestCase {
+
+ @Test
+ public void testIsAnyPrefixOf() {
+ Collection<String> possiblePrefixes = asList("", "/");
+ assertTrue(isAnyPrefixOf("", possiblePrefixes));
+
+ possiblePrefixes = asList("", "/");
+ assertTrue(isAnyPrefixOf("/", possiblePrefixes));
+
+ possiblePrefixes = asList("a");
+ assertTrue(isAnyPrefixOf("a", possiblePrefixes));
+
+ possiblePrefixes = asList("a/");
+ assertTrue(isAnyPrefixOf("a", possiblePrefixes));
+
+ possiblePrefixes = asList("b");
+ assertFalse(isAnyPrefixOf("a", possiblePrefixes));
+
+ possiblePrefixes = asList("b", "ab", "b/", "aa");
+ assertFalse(isAnyPrefixOf("a", possiblePrefixes));
+ }
+
+ @Test
+ public void testMergeIgnored() {
+ Set<String> result;
+ Set<String> expected = new HashSet<String>();
+ Set<String> oldIgnoredPaths = new HashSet<String>();
+ Collection<String> changedPaths = new HashSet<String>();
+ Set<String> newIgnoredPaths = new HashSet<String>();
+
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+
+ newIgnoredPaths.add("a");
+ changedPaths.add("a");
+ expected.add("a");
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+
+ newIgnoredPaths.add("b");
+ expected.add("b");
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+
+ changedPaths.add("b");
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+
+ oldIgnoredPaths.add("b");
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+
+ oldIgnoredPaths.add("c");
+ expected.add("c");
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+
+ newIgnoredPaths.add("b");
+ expected.add("b");
+ result = mergeIgnored(oldIgnoredPaths, changedPaths, newIgnoredPaths);
+ assertEquals(expected, result);
+ }
+}

Back to the top