Attachment #211682 for bug #366016

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation 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

    public Object[] fetchChildren(Object o, IProgressMonitor monitor) throws TeamException {
        if (!(o instanceof ICVSRemoteFolder))
            return new Object[0];
		try {
			monitor = Policy.monitorFor(monitor);
			monitor.beginTask(NLS.bind(
					CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
					new String[] { getLabel(o) }), 150);
			ICVSRemoteFolder folder = (ICVSRemoteFolder) o;
			ICVSRemoteResource[] cachedChildren = CVSUIPlugin
					.getPlugin()
					.getRepositoryManager()
					.getCachedChildrenForTag(folder.getRepository(), folder,
							folder.getTag(), Policy.subMonitorFor(monitor, 50));
			if (cachedChildren.length > 0) {
				return cachedChildren;
			}
			return folder.members(Policy.subMonitorFor(monitor, 100));
		} finally {
			monitor.done();
		}
    }

    public void fetchDeferredChildren(Object o, IElementCollector collector, IProgressMonitor monitor) {

		}
        try {
            monitor = Policy.monitorFor(monitor);
			monitor.beginTask(NLS.bind(
					CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
					new String[] { getLabel(o) }), 150);
			ICVSRemoteFolder folder = (ICVSRemoteFolder) o;
			ICVSRemoteResource[] cachedChildren = CVSUIPlugin
					.getPlugin()
					.getRepositoryManager()
					.getCachedChildrenForTag(folder.getRepository(), folder,
							folder.getTag(), Policy.subMonitorFor(monitor, 50));
			if (cachedChildren.length > 0) {
				collector.add(cachedChildren, monitor);
				return;
			}
			FetchMembersOperation operation = new FetchMembersOperation(null, (ICVSRemoteFolder)o, collector);
			operation.run(Policy.subMonitorFor(monitor, 100));
        } catch (InvocationTargetException e) {
            handle(collector, e);
		} catch (InterruptedException e) {
			// Cancelled by the user;
		} catch (CVSException e) {
			handle(collector, e);
		} finally {
            monitor.done();
        }




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation 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

		Set result = new HashSet();
		RepositoryRoot root = (RepositoryRoot)repositoryRoots.get(location.getLocation(false));
		if (root != null) {
			CVSTag[] tags = root.getAllKnownTags();
			for (int i = 0; i < tags.length; i++) {
				CVSTag tag = tags[i];
				if (tag.getType() == tagType)
					result.add(tag);
					CVSTag tag = tags[j];
					if (tag.getType() == tagType)
						result.add(tag);
				}
			}
		}
		return (CVSTag[])result.toArray(new CVSTag[0]);

			Set result = new HashSet();
			// Get the tags for the location
			RepositoryRoot root = getRepositoryRootFor(location);
			String[] paths = root.getRemoteChildrenForTag(null, tag);
			for (int i = 0; i < paths.length; i++) {
				String path = paths[i];
				ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
						Policy.subMonitorFor(monitor, 100));
				result.add(remote);
					result.add(remote);
				}
			}
			return (ICVSRemoteResource[])result.toArray(new ICVSRemoteResource[result.size()]);
		} finally {
			monitor.done();
		}
	}

	/**
	 * Returns a list of child resources for given folder that are known to
	 * contain given tag. If the return list is empty than given tag exists
	 * directly in given folder and its children should be retrieved directly
	 * from the repository.
	 * 
	 * @param location
	 *            CVS repository location
	 * @param parentFolder
	 *            folder to check tags for
	 * @param tag
	 * @param monitor
	 * @return a list of remote resources that are known to contain given tag or
	 *         empty list if resources should be retrieved from the repository
	 * @throws CVSException
	 */
	public ICVSRemoteResource[] getCachedChildrenForTag(
			ICVSRepositoryLocation location, ICVSRemoteFolder parentFolder,
			CVSTag tag, IProgressMonitor monitor) throws CVSException {
		if (tag == null || tag.getType() == CVSTag.HEAD
				|| tag.getType() == CVSTag.DATE) {
			// folders are kept in cache only for tags and versions
			return new ICVSRemoteResource[0];
		}
		monitor = Policy.monitorFor(monitor);
		Set result = new HashSet();
		RepositoryRoot root = getRepositoryRootFor(location);
		// if remote folder is null return the subfolders of repository root
		String[] paths = root.getRemoteChildrenForTag(
				parentFolder == null ? null : RepositoryRoot
						.getRemotePathFor(parentFolder), tag);
		monitor.beginTask(NLS
				.bind(CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
						new String[] { NLS.bind(
								CVSUIMessages.RemoteFolderElement_nameAndTag,
								new String[] { parentFolder.getName(),
										tag.getName() }) }), 10 * paths.length);
		try {
			for (int i = 0; i < paths.length; i++) {
				String path = paths[i];
				ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
						Policy.subMonitorFor(monitor, 10));
				result.add(remote);
			}
			return (ICVSRemoteResource[]) result
					.toArray(new ICVSRemoteResource[result.size()]);
		} finally {
			monitor.done();
		}
	}
		
	/*
	 * Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file




/*******************************************************************************
 * Copyright (c) 2000, 2012 IBM Corporation 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

import org.eclipse.team.internal.ccvs.ui.Policy;
import org.eclipse.team.internal.ccvs.ui.operations.RemoteLogOperation;
import org.eclipse.team.internal.ccvs.ui.operations.RemoteLogOperation.LogEntryCache;
import org.eclipse.team.internal.ccvs.ui.tags.TagSource;

public class RepositoryRoot extends PlatformObject {


	
	ICVSRepositoryLocation root;
	String name;
	TagCacheEntry rootTagCacheEntry = new TagCacheEntry(Path.ROOT.toString(),
			null);
	// Map of String (remote folder path) -> Set (file paths that are project relative)
	Map autoRefreshFiles = new HashMap();
	// Map of String (module name) -> ICVSRemoteFolder (that is a defined module)

	List dateTags = new ArrayList();
	
	public static class TagCacheEntry {
		String path;
		// Set of tags found for this path
	    Set tags = new HashSet();
		// String(last path segment) -> TagCacheEntry for child paths
		Map children = new HashMap();
		TagCacheEntry parent;
	    long lastAccessTime;
        private static final int CACHE_LIFESPAN_IN_DAYS = 7;

		public TagCacheEntry(String path, TagCacheEntry parent) {
			this.path = path;
			this.parent = parent;
			accessed();
		}

        public boolean isExpired() {
            long currentTime = System.currentTimeMillis();
            long ms = currentTime - lastAccessTime;

	 * 
	 * It is the responsibility of the caller to ensure that the given remote path is valid.
	 */
	public void addTags(String remotePath, CVSTag[] tags) {
		if (tags.length == 0) {
			return;
		}
		addDateTags(tags);
		addVersionAndBranchTags(remotePath, tags);
	}

		}
	}
	private void addVersionAndBranchTags(String remotePath, CVSTag[] tags) {
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, true);
		entry.accessed();

		// Make sure there is a table for the ancestor that holds the tags
		TagCacheEntry entry = (TagCacheEntry)versionAndBranchTags.get(name);
		if (entry == null) {
		    entry = new TagCacheEntry();
			versionAndBranchTags.put(name, entry);
		} else {
		    entry.accessed();
		}
		
		// Store the tag with the appropriate ancestor
		for (int i = 0; i < tags.length; i++) {
			if (tags[i].getType() != CVSTag.DATE) {
				if (!getAllKnownTagsForParents(entry).contains(tags[i])) {
					removeTagFromChildrenCacheEntries(entry, tags[i], false);
					entry.tags.add(tags[i]);
				}
			}
		}
	}

	}

	private void removeVersionAndBranchTags(String remotePath, CVSTag[] tags) {
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		// remove tags from this path and its children
		if (entry != null) {
			removeTagsFromChildrenChacheEntries(entry, tags);
		}

		// remove tags from all parents of this path
		entry = getKnownParentTagCacheEntryFor(remotePath);
		for (int i = 0; i < tags.length; i++) {
			TagCacheEntry currentEntry = entry;
			while (currentEntry != null) {
				if (currentEntry.tags.contains(tags[i])) {
					currentEntry.tags.remove(tags[i]);
					currentEntry.accessed();
					break;
				} else {
					currentEntry = currentEntry.parent;
				}
			}
		}
		cleanEmptyParents(entry);
	}

	private void cleanEmptyParents(TagCacheEntry entry) {
		if (entry.parent == null) {
			// we don't remove the root cache entry
			return;
		}
		if (entry.tags.isEmpty() && entry.children.isEmpty()) {
			entry.parent.children.remove(new Path(entry.path).lastSegment());
			entry.parent.accessed();
			entry.tags.remove(tags[i]);
		}
		cleanEmptyParents(entry.parent);
	}

	/**

	 * @return String[]
	 */
	public String[] getAutoRefreshFiles(String remotePath) {
		Set files = (Set) autoRefreshFiles.get(remotePath);
		Set files = (Set)autoRefreshFiles.get(name);
		if (files == null || files.isEmpty()) {
			// convert the default relative file paths to full paths
			if (isDefinedModuleName(remotePath)) {

				}
			}
			if (isDefault) {
				this.autoRefreshFiles.remove(remotePath);
				return;
			}
		}
		this.autoRefreshFiles.put(remotePath, newFiles);
	}

	/**
	 * Fetches tags from auto-refresh files.
	 */
	public CVSTag[] refreshDefinedTags(ICVSFolder folder, boolean recurse,
			IProgressMonitor monitor) throws TeamException {
		monitor = Policy.monitorFor(monitor);
		monitor.beginTask(null, recurse ? 210 : 100);
		try {
			CVSTag[] tags = null;
			if (!folder.getFolderSyncInfo().isVirtualDirectory()) {
				// Only try the auto-refresh file(s) if we are not recursing
				// into sub-folders
				tags = fetchTagsUsingAutoRefreshFiles(folder,
						Policy.subMonitorFor(monitor, 50));
			}
			if (tags == null || tags.length == 0) {
				// There we're no tags found on the auto-refresh files or we
				// we're asked to go deep
				// Try using the log command
				tags = fetchTagsUsingLog(folder,
						Policy.subMonitorFor(monitor, 50));
			}
			if (tags != null && tags.length > 0) {
				String remotePath = getRemotePathFor(folder);
				addTags(remotePath, tags);
				return tags;
			}
			if (recurse) {
				folder.fetchChildren(Policy.subMonitorFor(monitor, 10));
				ICVSResource[] children = folder
						.members(ICVSFolder.FOLDER_MEMBERS);
				for (int i = 0; i < children.length; i++) {
					refreshDefinedTags(
							(ICVSFolder) children[i],
							recurse,
							Policy.subMonitorFor(monitor, 100 / children.length));
				}
			}
			return tags;
		} finally {
			monitor.done();
		}
		monitor.done();
		return tags;
	}
	
    private CVSTag[] fetchTagsUsingLog(ICVSFolder folder, IProgressMonitor monitor) throws CVSException {
        LogEntryCache logEntries = new LogEntryCache();
        RemoteLogOperation operation = new RemoteLogOperation(null, new ICVSRemoteResource[] { asRemoteResource(folder) }, null, null, logEntries) {
            protected Command.LocalOption[] getLocalOptions(CVSTag tag1,CVSTag tag2) {
                Command.LocalOption[] options = new Command.LocalOption[] {};
                if (recurse) 
                    return options;
                Command.LocalOption[] newOptions = new Command.LocalOption[options.length + 1];
                System.arraycopy(options, 0, newOptions, 0, options.length);
                newOptions[options.length] = Command.DO_NOT_RECURSE;

		}
		return (CVSTag[])tagSet.toArray(new CVSTag[0]);
	}

	private TagCacheEntry getTagCacheEntryFor(String remotePath, boolean create) {
		String[] segments = new Path(null, remotePath).segments();
		TagCacheEntry currentTagCacheEntry = rootTagCacheEntry;
		for (int i = 0; i < segments.length; i++) {
			String segment = segments[i];
			if (currentTagCacheEntry.children.containsKey(segment)) {
				currentTagCacheEntry = (TagCacheEntry) currentTagCacheEntry.children
						.get(segment);
				continue;
			}
			if (!create) {
				return null;
			}
			TagCacheEntry newTagCacheEntry = new TagCacheEntry(new Path(null,
					remotePath).removeLastSegments(segments.length - (i + 1))
					.toString(), currentTagCacheEntry);
			currentTagCacheEntry.children.put(segment, newTagCacheEntry);
			currentTagCacheEntry = newTagCacheEntry;
		}
		return currentTagCacheEntry;
	}

	private TagCacheEntry getKnownParentTagCacheEntryFor(String remotePath) {
		String[] segments = new Path(null, remotePath).segments();
		TagCacheEntry currentTagCacheEntry = rootTagCacheEntry;
		for (int i = 0; i < segments.length; i++) {
			String segment = segments[i];
			if (currentTagCacheEntry.children.containsKey(segment)) {
				currentTagCacheEntry = (TagCacheEntry) currentTagCacheEntry.children
						.get(segment);
			} else {
				break; // we reached the last existing parent
			}
		}
		return currentTagCacheEntry;
	}

	private void removeTagsFromChildrenChacheEntries(TagCacheEntry entry,
			CVSTag[] tags) {
		for (int i = 0; i < tags.length; i++) {
			removeTagFromChildrenCacheEntries(entry, tags[i], true);
		}
	}

	private void removeTagFromChildrenCacheEntries(TagCacheEntry entry,
			CVSTag tag, boolean includeThisEntry) {
		Iterator childrenIterator = entry.children.values().iterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			removeTagFromChildrenCacheEntries(child, tag, true);
		}
		if (includeThisEntry) {
			entry.tags.remove(tag);
			entry.accessed();
			if (entry.tags.size() == 0 && entry.children.size() == 0
					&& entry.parent != null) {
				// remove this entry when the last tag was removed
				// keep the entry if there are any children that have tags
				Map newParentChildren = new HashMap();
				newParentChildren.putAll(entry.parent.children);
				newParentChildren.remove(new Path(entry.path).lastSegment());
				entry.parent.children = newParentChildren;
			}
		}
	}
	
	/**

				attributes.put(RepositoriesViewContentHandler.TYPE_ATTRIBUTE, RepositoriesViewContentHandler.DEFINED_MODULE_TYPE);
			}
			attributes.put(RepositoriesViewContentHandler.PATH_ATTRIBUTE, name);
			TagCacheEntry entry = (TagCacheEntry) getTagCacheEntryFor(path,
					false);
			boolean writeOutTags = entry != null && !entry.isExpired();
			if (writeOutTags)
			    attributes.put(RepositoriesViewContentHandler.LAST_ACCESS_TIME_ATTRIBUTE, Long.toString(entry.lastAccessTime));

		writer.startAndEndTag(s, attributes, true);
	}

	private Set getAllKnownTagsForParents(TagCacheEntry entry) {
		Set tags = new HashSet();
		if (entry.parent != null) {
			tags.addAll(getAllKnownTagsForParents(entry.parent));
		}
		tags.addAll(entry.tags);
		return tags;
	}

	private Set getAllKnownTagsForChildren(TagCacheEntry entry) {
		Set tags = new HashSet();
		Iterator childrenIterator = entry.children.values().iterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			tags.addAll(getAllKnownTagsForChildren(child));
		}
		tags.addAll(entry.tags);
		return tags;
	}

	/**
	 * Method getKnownTags.
	 * @param remotePath
	 * @return CVSTag[]
	 */
	public CVSTag[] getAllKnownTags(String remotePath) {
		Set tags = getAllKnownTagsForParents(getKnownParentTagCacheEntryFor(remotePath));
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		if (entry != null) {
			tags.addAll(getAllKnownTagsForChildren(entry));
			CVSTag[] tags2 = getDateTags();
			int len = tags1.length + tags2.length;
			CVSTag[] tags = new CVSTag[len];
			for(int i = 0; i < len; i++){
				if(i < tags1.length){
					tags[i] = tags1[i];
				}else{
					tags[i] = tags2[i-tags1.length];
				}
			}
			return tags;
		}
		return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]);
	}

	public CVSTag[] getAllKnownTags() {
		Set tags = getAllKnownTagsForChildren(rootTagCacheEntry);
		return (CVSTag[]) tags.toArray(new CVSTag[tags.size()]);
	}

	public String[] getRemoteChildrenForTag(String remotePath, CVSTag tag) {
		TagCacheEntry entry;
		if (remotePath == null) {
			entry = rootTagCacheEntry;
		} else {
			entry = getTagCacheEntryFor(remotePath, false);
		}
		if (entry == null) {
			return new String[0];
		}

		Set paths = new HashSet();
		Iterator childrenIterator = entry.children.values().iterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			if (getAllKnownTagsForChildren(child).contains(tag)) {
				paths.add(child.path);
			}
		}
		return (String[]) paths.toArray(new String[paths.size()]);
	}
	
	private Set getKnownRemotePaths(TagCacheEntry root) {
		Set paths = new HashSet();
		Iterator childrenIterator = root.children.values().iterator();
		while(childrenIterator.hasNext()){
			paths.addAll(getKnownRemotePaths((TagCacheEntry) childrenIterator.next()));
		}
		paths.add(root.path);
		return paths;
		
	}
	public String[] getKnownRemotePaths() {
		Set paths =  getKnownRemotePaths(rootTagCacheEntry);
		paths.addAll(autoRefreshFiles.keySet());
		return (String[]) paths.toArray(new String[paths.size()]);
	}

	public boolean tagIsKnown(ICVSRemoteResource remoteResource) {
		if (remoteResource instanceof ICVSRemoteFolder) {
			ICVSRemoteFolder folder = (ICVSRemoteFolder) remoteResource;
			String path = folder.getRepositoryRelativePath();
			CVSTag[] tags = getAllKnownTags(path);
			CVSTag tag = folder.getTag();
			for (int i = 0; i < tags.length; i++) {

     * as it was read from the persistent store.
     */
    /* package */ void setLastAccessedTime(String remotePath, long lastAccessTime) {
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		if(entry != null){
		    entry.lastAccessTime = lastAccessTime;
		}

Lines 34-39 Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/provider/AllTestsProvider.java (+1 lines)
34	suite.addTest(WatchEditTest.suite());	34	suite.addTest(WatchEditTest.suite());
35	suite.addTest(LinkResourcesTest.suite());	35	suite.addTest(LinkResourcesTest.suite());
36	suite.addTest(IsModifiedTests.suite());	36	suite.addTest(IsModifiedTests.suite());
		37	suite.addTest(CVSCacheTest.suite());
37	return new CVSTestSetup(suite);	38	return new CVSTestSetup(suite);
38	}	39	}
39	}	40	}




/*******************************************************************************
 * Copyright (c) 2012 IBM Corporation 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.tests.ccvs.core.provider;

import java.util.Arrays;
import java.util.List;

import junit.framework.Test;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.team.internal.ccvs.core.CVSException;
import org.eclipse.team.internal.ccvs.core.CVSTag;
import org.eclipse.team.internal.ccvs.core.ICVSFolder;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
import org.eclipse.team.internal.ccvs.ui.repo.RepositoryManager;
import org.eclipse.team.internal.ccvs.ui.repo.RepositoryRoot;
import org.eclipse.team.tests.ccvs.core.EclipseTest;

public class CVSCacheTest extends EclipseTest {

	private RepositoryRoot repositoryRoot;
	private RepositoryManager repositoryManager;

	protected void setUp() throws Exception {
		super.setUp();
		repositoryManager = CVSUIPlugin.getPlugin().getRepositoryManager();
		repositoryRoot = getRepositoryRoot();
		clearRepositoryRootCache();
	}

	public static Test suite() {
		return suite(CVSCacheTest.class);
	}

	private RepositoryRoot getRepositoryRoot() {
		Object[] repositoryRoots = repositoryManager.getKnownRepositoryRoots();
		for (int i = 0; i < repositoryRoots.length; i++) {
			RepositoryRoot repositoryRoot = (RepositoryRoot) repositoryRoots[i];
			if (getRepository().equals(repositoryRoot.getRoot())) {
				return repositoryRoot;
			}
		}
		fail(getRepository() + " not found");
		return null;
	}

	private void clearRepositoryRootCache() {
		String remotePaths[] = repositoryRoot.getKnownRemotePaths();
		for (int i = 0; i < remotePaths.length; i++) {
			repositoryRoot.removeTags(remotePaths[i],
					repositoryRoot.getAllKnownTags(remotePaths[i]));
		}
		// verify if tags where cleared
		assertEquals("Repository cache was not cleaned.", 0,
				repositoryRoot.getAllKnownTags().length);
	}

	private IProject createProject(String baseName, String repoPrefix)
			throws CoreException {
		// create project
		IProject project = getUniqueTestProject(baseName);
		// share project under module
		shareProject(getRepository(), project,
				repoPrefix == null ? project.getName()
						: (repoPrefix + "/" + project.getName()),
				DEFAULT_MONITOR);
		assertValidCheckout(project);
		// add some files
		addResources(project, new String[] { "file1.txt" }, true);
		return project;
	}

	private void assertTags(CVSCacheTestData data) throws CVSException {
		// Root should contain all known tags
		List knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertTrue(knownTags.contains(data.branches[2]));
		assertTrue(knownTags.contains(data.versions[2]));

		// Project_1 should contain Branch_1 and Branch_2
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project1)));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertFalse(knownTags.contains(data.branches[2]));
		assertFalse(knownTags.contains(data.versions[2]));

		// Project_2 should contain Branch_1 and Branch_3
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project2)));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertFalse(knownTags.contains(data.branches[1]));
		assertFalse(knownTags.contains(data.versions[1]));
		assertTrue(knownTags.contains(data.branches[2]));
		assertTrue(knownTags.contains(data.versions[2]));
	}

	private class CVSCacheTestData {
		IProject project1; // tagged with Branch_1 and Branch_2
		IProject project2; // tagged with Branch_1 and Branch_3
		CVSTag[] branches = new CVSTag[3];
		CVSTag[] versions = new CVSTag[3];

		private void init(String project1Path, String project2Path)
				throws CoreException {
			project1 = createProject("Project_1", project1Path);
			project2 = createProject("Project_2", project2Path);
			branches[0] = new CVSTag("Branch_1" + System.currentTimeMillis(),
					CVSTag.BRANCH);
			versions[0] = new CVSTag("Root_" + branches[0].getName(),
					CVSTag.VERSION);
			branches[1] = new CVSTag("Branch_2" + System.currentTimeMillis(),
					CVSTag.BRANCH);
			versions[1] = new CVSTag("Root_" + branches[1].getName(),
					CVSTag.VERSION);
			branches[2] = new CVSTag("Branch_3" + System.currentTimeMillis(),
					CVSTag.BRANCH);
			versions[2] = new CVSTag("Root_" + branches[2].getName(),
					CVSTag.VERSION);

			makeBranch(new IResource[] { project1, project2 }, versions[0],
					branches[0], true);
			makeBranch(new IResource[] { project1 }, versions[1], branches[1],
					true);
			makeBranch(new IResource[] { project2 }, versions[2], branches[2],
					true);
		}

		public CVSCacheTestData(String project1Path, String project2Path)
				throws CoreException {
			init(project1Path, project2Path);
		}
	}

	public void testProjectsOnMainLevel() throws CoreException {
		CVSCacheTestData data = new CVSCacheTestData(null, null);

		// verify that tags are correct after creating branches
		assertTags(data);

		// clear the cache and verify that tags are correct after refreshing on
		// project level
		clearRepositoryRootCache();
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(data.project1), true, true,
				DEFAULT_MONITOR);
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(data.project2), true, true,
				DEFAULT_MONITOR);
		assertTags(data);
	}

	public void testProjectsInSubmodule() throws CoreException {
		String submodule = "Submodule_1" + System.currentTimeMillis();
		CVSCacheTestData data = new CVSCacheTestData(submodule, submodule);
		ICVSFolder submoduleFolder = repositoryRoot.getRemoteFolder(submodule,
				null, getMonitor());

		// verify that tags are correct after creating branches
		assertTags(data);

		// clear the cache and verify that tags are correct after refreshing on
		// project level
		clearRepositoryRootCache();
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(data.project1), true, true,
				DEFAULT_MONITOR);
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(data.project2), true, true,
				DEFAULT_MONITOR);
		assertTags(data);
		// verify that parent module has tags from both projects
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertTrue(knownTags.contains(data.branches[2]));
		assertTrue(knownTags.contains(data.versions[2]));

		// clear the cache, refresh it only for submodule and verify if tags are
		// correct
		clearRepositoryRootCache();
		repositoryManager.refreshDefinedTags(submoduleFolder, true, true,
				DEFAULT_MONITOR);
		assertTags(data);
		// verify that parent module has tags from both projects
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertTrue(knownTags.contains(data.branches[2]));
		assertTrue(knownTags.contains(data.versions[2]));
	}

	public void testProjectsInTwoSubmodules() throws CoreException {
		String submodule1 = "Submodule_1" + System.currentTimeMillis();
		String submodule2 = "Submodule_2" + System.currentTimeMillis();
		CVSCacheTestData data = new CVSCacheTestData(submodule1, submodule2);
		ICVSFolder submoduleFolder1 = repositoryRoot.getRemoteFolder(
				submodule1, null, getMonitor());
		ICVSFolder submoduleFolder2 = repositoryRoot.getRemoteFolder(
				submodule2, null, getMonitor());

		// verify that tags are correct after creating branches
		assertTags(data);

		// clear the cache and verify that tags are correct after refreshing on
		// project level
		clearRepositoryRootCache();
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(data.project1), true, true,
				DEFAULT_MONITOR);
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(data.project2), true, true,
				DEFAULT_MONITOR);
		assertTags(data);
		// verify that parent modules have tags from subordinate project, but
		// not the other project
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder1));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertFalse(knownTags.contains(data.branches[2]));
		assertFalse(knownTags.contains(data.versions[2]));

		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder2));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertFalse(knownTags.contains(data.branches[1]));
		assertFalse(knownTags.contains(data.versions[1]));
		assertTrue(knownTags.contains(data.branches[2]));
		assertTrue(knownTags.contains(data.versions[2]));

		// clear the cache, refresh it only one for submodule and verify if tags
		// are correct
		clearRepositoryRootCache();
		repositoryManager.refreshDefinedTags(submoduleFolder1, true, true,
				DEFAULT_MONITOR);

		// verify that correct tags where added to this submodule
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder1));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertFalse(knownTags.contains(data.branches[2]));
		assertFalse(knownTags.contains(data.versions[2]));

		// verify if only tags from the first submodule are known
		knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertTrue(knownTags.contains(data.branches[1]));
		assertTrue(knownTags.contains(data.versions[1]));
		assertFalse(knownTags.contains(data.branches[2]));
		assertFalse(knownTags.contains(data.versions[2]));

		// refresh tags for the second submodule and verify if list of tags
		// where correctly merged
		repositoryManager.refreshDefinedTags(submoduleFolder2, true, true,
				DEFAULT_MONITOR);
		// verify tags for the second submodule
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder2));
		assertTrue(knownTags.contains(data.branches[0]));
		assertTrue(knownTags.contains(data.versions[0]));
		assertFalse(knownTags.contains(data.branches[1]));
		assertFalse(knownTags.contains(data.versions[1]));
		assertTrue(knownTags.contains(data.branches[2]));
		assertTrue(knownTags.contains(data.versions[2]));
		// verify if tags are merged correctly
		assertTags(data);
	}

	public void testRefreshProjectUsingAutoRefreshFile() throws CoreException {
		IProject project = createProject("Project_1", (String) null);
		String autoRefreshFileName = "sampleAuthoRefresh.txt";
		String notAutoRefreshFileName = "notAutoRefresh.txt";
		addResources(project, new String[] { autoRefreshFileName,
				notAutoRefreshFileName }, true);
		IFile autoRefreshFile = project.getFile(autoRefreshFileName);
		IFile notAutoRefreshFile = project.getFile(notAutoRefreshFileName);
		repositoryManager.setAutoRefreshFiles(
				CVSWorkspaceRoot.getCVSFolderFor(project),
				new String[] { CVSWorkspaceRoot.getCVSResourceFor(
						autoRefreshFile).getRepositoryRelativePath() });
		CVSTag branch1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
				CVSTag.BRANCH);
		CVSTag version1 = new CVSTag("Root_" + branch1.getName(),
				CVSTag.VERSION);
		// branch the auto refresh file
		makeBranch(new IResource[] { autoRefreshFile }, version1, branch1, true);
		CVSTag branch2 = new CVSTag("Branch_2" + System.currentTimeMillis(),
				CVSTag.BRANCH);
		CVSTag version2 = new CVSTag("Root_" + branch2.getName(),
				CVSTag.VERSION);
		// branch not auto refresh file
		makeBranch(new IResource[] { notAutoRefreshFile }, version2, branch2,
				true);

		clearRepositoryRootCache();
		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(project), true, true,
				DEFAULT_MONITOR);

		// cache should contain branches from auto refresh file, but no branches
		// from other files
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
		assertTrue(knownTags.contains(branch1));
		assertTrue(knownTags.contains(version1));
		assertFalse(knownTags.contains(branch2));
		assertFalse(knownTags.contains(version2));

	}

	public void testProjectWithNoTags() throws CoreException {
		IProject project = createProject("Project_1", (String) null);
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
		assertTrue(knownTags.isEmpty());

		repositoryManager.refreshDefinedTags(
				CVSWorkspaceRoot.getCVSFolderFor(project), true, true,
				DEFAULT_MONITOR);
		assertTrue(knownTags.isEmpty());
	}

}




/*******************************************************************************
 * Copyright (c) 2011, 2012 IBM Corporation 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


		// create project
		IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");
		buildResources(project, new String[] { "file1.txt" }, true);
		// share project under module
		shareProject(getRepository(), project,
				moduleName + "/" + project.getName(), DEFAULT_MONITOR);
		assertValidCheckout(project);

		// add some files
		addResources(project, new String[] { "file1.txt" }, true);

		// make branch
		CVSTag version = new CVSTag(versionName, CVSTag.VERSION);
		CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);

		makeBranch(new IResource[] { project }, version, branch, true);
		commitProject(project);

		// refresh branches
		CVSUIPlugin
				.getPlugin()
				.getRepositoryManager()
				.refreshDefinedTags(
						getRepository().getRemoteFolder(moduleName, null),
						true, true, DEFAULT_MONITOR);

		// check if module is the only branch child
		RemoteContentProvider rcp = new RemoteContentProvider();

		Object[] modules = rcp.getChildren(branches[0]);
		assertEquals(1, modules.length);
		assertEquals(moduleName, ((RemoteResource) modules[0]).getName());

		// refresh branches
		CVSUIPlugin
				.getPlugin()
				.getRepositoryManager()
				.refreshDefinedTags(
						getRepository().getRemoteFolder(moduleName, null),
						true, true, DEFAULT_MONITOR);

		// check if after refresh module is still the only branch child
		branches = rcp.getChildren(categories[1]);
		assertEquals(1, branches.length);
		assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
				.getName());
		modules = rcp.getChildren(branches[0]);
		assertEquals(1, modules.length);
		assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
	}

	public void testTagSubmoduleChildren() throws TeamException, CoreException {


		// create project
		IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");
		buildResources(project, new String[] { "file1.txt" }, true);
		// share project under module
		shareProject(getRepository(), project,
				moduleName + "/" + project.getName(), DEFAULT_MONITOR);
		assertValidCheckout(project);

		// add some files
		addResources(project, new String[] { "file1.txt" }, true);

		// tag project
		CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);

		tagProject(project, tag, true);

		// refresh branches
		CVSUIPlugin
				.getPlugin()
				.getRepositoryManager()
				.refreshDefinedTags(
						getRepository().getRemoteFolder(moduleName, null),
						true, true, DEFAULT_MONITOR);

		RemoteContentProvider rcp = new RemoteContentProvider();
		Object[] categories = rcp.getChildren(getRepositoryRoot());

		}
		fail(moduleName + " not found");
	}

	public void testTagsOnDifferentLevels() throws CoreException {
		String time = Long.toString(System.currentTimeMillis());
		String firstModule = "Module_1" + time;
		String secondModule = "Module_2" + time;
		String secondModulePath = firstModule + "/" + secondModule;
		// Create repository data
		// Module_1/Project_1
		IProject project1 = getUniqueTestProject("Project_1");
		shareProject(getRepository(), project1,
				firstModule + "/" + project1.getName(), DEFAULT_MONITOR);
		// Module_1/Module_2/Project_2
		IProject project2 = getUniqueTestProject("Project_2");
		shareProject(getRepository(), project2, secondModulePath + "/"
				+ project2.getName(), DEFAULT_MONITOR);
		// Module_1/Module_2/Project_3
		IProject project3 = getUniqueTestProject("Project_3");
		shareProject(getRepository(), project3, secondModulePath + "/"
				+ project3.getName(), DEFAULT_MONITOR);
		// Module_1/Project_4
		IProject project4 = getUniqueTestProject("Project_4");
		shareProject(getRepository(), project4,
				firstModule + "/" + project4.getName(), DEFAULT_MONITOR);

		// Create branches
		String branch1 = "Branch_1" + time;
		String version1 = "Root_" + branch1;
		String branch2 = "Branch_2" + time;
		String version2 = "Root_" + branch2;

		// Tag projects:
		// Module_1/Project_1 -> [Branch_1][Branch_2]
		// Module_1/Module_2/Project_2 -> [Branch_1][Branch_2]
		// Module_1/Module_2/Project_3 -> [Branch_2]
		// Module_1/Project_4 -> [Branch_4]
		makeBranch(new IResource[] { project1, project2 }, new CVSTag(version1,
				CVSTag.VERSION), new CVSTag(branch1, CVSTag.BRANCH), true);
		makeBranch(new IResource[] { project1, project2, project2, project4 },
				new CVSTag(version2, CVSTag.VERSION), new CVSTag(branch2,
						CVSTag.BRANCH), true);

		// verify if tree structure is built from cache
		RemoteContentProvider rcp = new RemoteContentProvider();
		Object[] categories = rcp.getChildren(getRepositoryRoot());
		assertEquals(4, categories.length);
		assertTrue(categories[1] instanceof BranchCategory);
		Object[] branches = rcp.getChildren(categories[1]);
		assertEquals(2, branches.length); // should be [Branch_1] and [Branch_2]
		CVSTagElement branch1Element;
		CVSTagElement branch2Element;
		if (((CVSTagElement) branches[0]).getTag().getName().equals(branch1)) {
			branch1Element = (CVSTagElement) branches[0];
			branch2Element = (CVSTagElement) branches[1];
		} else {
			branch1Element = (CVSTagElement) branches[1];
			branch2Element = (CVSTagElement) branches[0];
		}
		Object[] modules = rcp.getChildren(branch1Element);
		assertEquals(1, modules.length); // should be [Branch_1]/Module_1
		assertEquals(firstModule, ((RemoteResource) modules[0]).getName());
		modules = rcp.getChildren(modules[0]);
		// should contain:
		// [Branch_1]/Module_1/Project_1
		// [Branch_1]/Module_1/Module_2
		assertEquals(2, modules.length);
		for (int i = 0; i < modules.length; i++) {
			if (((RemoteResource) (modules[i])).getName().equals(
					project1.getName())) {
				// Project_1 should have contents retrieved from CVS
				assertTrue(rcp.hasChildren(modules[i]));
			} else if (((RemoteResource) (modules[i])).getName().equals(
					secondModule)) {
				// should be only [Branch_1]/Module_1/Module_2/Project_2.
				// [Branch_1]/Module_1/Module_2/Project_3 should NOT be on the
				// list, it is not branched with Branch_1
				Object[] module2Children = rcp.getChildren(modules[i]);
				assertEquals(1, module2Children.length);
				assertEquals(project2.getName(),
						((RemoteResource) module2Children[0]).getName());
			}
		}
		modules = rcp.getChildren(branch2Element);
		assertEquals(1, modules.length); // should be [Branch_2]/Module_1
		assertEquals(firstModule, ((RemoteResource) modules[0]).getName());
		// should contain:
		// [Branch_2]/Module_1/Project_1
		// [Branch_2]/Module_1/Module_2
		// [Branch_2]/Module_1/Project_4
		modules = rcp.getChildren(modules[0]);
		assertEquals(3, modules.length);
	}
}

Return to bug 366016

Lines 1-5 Link Here

(-)a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/repo/RepositoryManager.java (-16 / +61 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 142-156 Link Here
142	Set result = new HashSet();	142	Set result = new HashSet();
143	RepositoryRoot root = (RepositoryRoot)repositoryRoots.get(location.getLocation(false));	143	RepositoryRoot root = (RepositoryRoot)repositoryRoots.get(location.getLocation(false));
144	if (root != null) {	144	if (root != null) {
145	String[] paths = root.getKnownRemotePaths();	145	CVSTag[] tags = root.getAllKnownTags();
146	for (int i = 0; i < paths.length; i++) {	146	for (int i = 0; i < tags.length; i++) {
147	String path = paths[i];	147	CVSTag tag = tags[i];
148	CVSTag[] tags = root.getAllKnownTags(path);	148	if (tag.getType() == tagType)
149	for (int j = 0; j < tags.length; j++) {	149	result.add(tag);
150	CVSTag tag = tags[j];
151	if (tag.getType() == tagType)
152	result.add(tag);
153	}
154	}	150	}
155	}	151	}
156	return (CVSTag[])result.toArray(new CVSTag[0]);	152	return (CVSTag[])result.toArray(new CVSTag[0]);
Lines 225-244 Link Here
225	Set result = new HashSet();	221	Set result = new HashSet();
226	// Get the tags for the location	222	// Get the tags for the location
227	RepositoryRoot root = getRepositoryRootFor(location);	223	RepositoryRoot root = getRepositoryRootFor(location);
228	String[] paths = root.getKnownRemotePaths();	224	String[] paths = root.getRemoteChildrenForTag(null, tag);
229	for (int i = 0; i < paths.length; i++) {	225	for (int i = 0; i < paths.length; i++) {
230	String path = paths[i];	226	String path = paths[i];
231	List tags = Arrays.asList(root.getAllKnownTags(path));	227	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
232	if (tags.contains(tag)) {	228	Policy.subMonitorFor(monitor, 100));
233	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag, Policy.subMonitorFor(monitor, 100));	229	result.add(remote);
234	result.add(remote);
235	}
236	}	230	}
237	return (ICVSRemoteResource[])result.toArray(new ICVSRemoteResource[result.size()]);	231	return (ICVSRemoteResource[])result.toArray(new ICVSRemoteResource[result.size()]);
238	} finally {	232	} finally {
239	monitor.done();	233	monitor.done();
240	}	234	}
241	}	235	}
		236
		237	/**
		238	* Returns a list of child resources for given folder that are known to
		239	* contain given tag. If the return list is empty than given tag exists
		240	* directly in given folder and its children should be retrieved directly
		241	* from the repository.
		242	*
		243	* @param location
		244	* CVS repository location
		245	* @param parentFolder
		246	* folder to check tags for
		247	* @param tag
		248	* @param monitor
		249	* @return a list of remote resources that are known to contain given tag or
		250	* empty list if resources should be retrieved from the repository
		251	* @throws CVSException
		252	*/
		253	public ICVSRemoteResource[] getCachedChildrenForTag(
		254	ICVSRepositoryLocation location, ICVSRemoteFolder parentFolder,
		255	CVSTag tag, IProgressMonitor monitor) throws CVSException {
		256	if (tag == null \|\| tag.getType() == CVSTag.HEAD
		257	\|\| tag.getType() == CVSTag.DATE) {
		258	// folders are kept in cache only for tags and versions
		259	return new ICVSRemoteResource[0];
		260	}
		261	monitor = Policy.monitorFor(monitor);
		262	Set result = new HashSet();
		263	RepositoryRoot root = getRepositoryRootFor(location);
		264	// if remote folder is null return the subfolders of repository root
		265	String[] paths = root.getRemoteChildrenForTag(
		266	parentFolder == null ? null : RepositoryRoot
		267	.getRemotePathFor(parentFolder), tag);
		268	monitor.beginTask(NLS
		269	.bind(CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
		270	new String[] { NLS.bind(
		271	CVSUIMessages.RemoteFolderElement_nameAndTag,
		272	new String[] { parentFolder.getName(),
		273	tag.getName() }) }), 10 * paths.length);
		274	try {
		275	for (int i = 0; i < paths.length; i++) {
		276	String path = paths[i];
		277	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
		278	Policy.subMonitorFor(monitor, 10));
		279	result.add(remote);
		280	}
		281	return (ICVSRemoteResource[]) result
		282	.toArray(new ICVSRemoteResource[result.size()]);
		283	} finally {
		284	monitor.done();
		285	}
		286	}
242		287
243	/*	288	/*
244	* Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file	289	* Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file

Lines 1-5 Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/RepositoriesViewTests.java (-14 / +122 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2011 IBM Corporation and others.	2	* Copyright (c) 2011, 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 82-110 Link Here
82		82
83	// create project	83	// create project
84	IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");	84	IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");
85	buildResources(project, new String[] { "file1.txt" }, true);
86	// share project under module	85	// share project under module
87	shareProject(getRepository(), project,	86	shareProject(getRepository(), project,
88	moduleName + "/" + project.getName(), DEFAULT_MONITOR);	87	moduleName + "/" + project.getName(), DEFAULT_MONITOR);
89	assertValidCheckout(project);	88	assertValidCheckout(project);
90		89
91	// make some changes	90	// add some files
92	addResources(project, new String[] { "folder1/c.txt" }, false);	91	addResources(project, new String[] { "file1.txt" }, true);
93		92
94	// make branch	93	// make branch
95	CVSTag version = new CVSTag(versionName, CVSTag.VERSION);	94	CVSTag version = new CVSTag(versionName, CVSTag.VERSION);
96	CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);	95	CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);
97		96
98	makeBranch(new IResource[] { project }, version, branch, true);	97	makeBranch(new IResource[] { project }, version, branch, true);
99	commitProject(project);
100
101	// refresh branches
102	CVSUIPlugin
103	.getPlugin()
104	.getRepositoryManager()
105	.refreshDefinedTags(
106	getRepository().getRemoteFolder(moduleName, null),
107	true, true, DEFAULT_MONITOR);
108		98
109	// check if module is the only branch child	99	// check if module is the only branch child
110	RemoteContentProvider rcp = new RemoteContentProvider();	100	RemoteContentProvider rcp = new RemoteContentProvider();
Lines 118-123 Link Here
118	Object[] modules = rcp.getChildren(branches[0]);	108	Object[] modules = rcp.getChildren(branches[0]);
119	assertEquals(1, modules.length);	109	assertEquals(1, modules.length);
120	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());	110	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
		111
		112	// refresh branches
		113	CVSUIPlugin
		114	.getPlugin()
		115	.getRepositoryManager()
		116	.refreshDefinedTags(
		117	getRepository().getRemoteFolder(moduleName, null),
		118	true, true, DEFAULT_MONITOR);
		119
		120	// check if after refresh module is still the only branch child
		121	branches = rcp.getChildren(categories[1]);
		122	assertEquals(1, branches.length);
		123	assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
		124	.getName());
		125	modules = rcp.getChildren(branches[0]);
		126	assertEquals(1, modules.length);
		127	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
121	}	128	}
122		129
123	public void testTagSubmoduleChildren() throws TeamException, CoreException {	130	public void testTagSubmoduleChildren() throws TeamException, CoreException {
Lines 128-143 Link Here
128		135
129	// create project	136	// create project
130	IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");	137	IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");
131	buildResources(project, new String[] { "file1.txt" }, true);
132	// share project under module	138	// share project under module
133	shareProject(getRepository(), project,	139	shareProject(getRepository(), project,
134	moduleName + "/" + project.getName(), DEFAULT_MONITOR);	140	moduleName + "/" + project.getName(), DEFAULT_MONITOR);
135	assertValidCheckout(project);	141	assertValidCheckout(project);
136		142
		143	// add some files
		144	addResources(project, new String[] { "file1.txt" }, true);
		145
137	// tag project	146	// tag project
138	CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);	147	CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);
139		148
140	tagProject(project, tag, true);	149	tagProject(project, tag, true);
		150
		151	// refresh branches
		152	CVSUIPlugin
		153	.getPlugin()
		154	.getRepositoryManager()
		155	.refreshDefinedTags(
		156	getRepository().getRemoteFolder(moduleName, null),
		157	true, true, DEFAULT_MONITOR);
141		158
142	RemoteContentProvider rcp = new RemoteContentProvider();	159	RemoteContentProvider rcp = new RemoteContentProvider();
143	Object[] categories = rcp.getChildren(getRepositoryRoot());	160	Object[] categories = rcp.getChildren(getRepositoryRoot());
Lines 159-162 Link Here
159	}	176	}
160	fail(moduleName + " not found");	177	fail(moduleName + " not found");
161	}	178	}
		179
		180	public void testTagsOnDifferentLevels() throws CoreException {
		181	String time = Long.toString(System.currentTimeMillis());
		182	String firstModule = "Module_1" + time;
		183	String secondModule = "Module_2" + time;
		184	String secondModulePath = firstModule + "/" + secondModule;
		185	// Create repository data
		186	// Module_1/Project_1
		187	IProject project1 = getUniqueTestProject("Project_1");
		188	shareProject(getRepository(), project1,
		189	firstModule + "/" + project1.getName(), DEFAULT_MONITOR);
		190	// Module_1/Module_2/Project_2
		191	IProject project2 = getUniqueTestProject("Project_2");
		192	shareProject(getRepository(), project2, secondModulePath + "/"
		193	+ project2.getName(), DEFAULT_MONITOR);
		194	// Module_1/Module_2/Project_3
		195	IProject project3 = getUniqueTestProject("Project_3");
		196	shareProject(getRepository(), project3, secondModulePath + "/"
		197	+ project3.getName(), DEFAULT_MONITOR);
		198	// Module_1/Project_4
		199	IProject project4 = getUniqueTestProject("Project_4");
		200	shareProject(getRepository(), project4,
		201	firstModule + "/" + project4.getName(), DEFAULT_MONITOR);
		202
		203	// Create branches
		204	String branch1 = "Branch_1" + time;
		205	String version1 = "Root_" + branch1;
		206	String branch2 = "Branch_2" + time;
		207	String version2 = "Root_" + branch2;
		208
		209	// Tag projects:
		210	// Module_1/Project_1 -> [Branch_1][Branch_2]
		211	// Module_1/Module_2/Project_2 -> [Branch_1][Branch_2]
		212	// Module_1/Module_2/Project_3 -> [Branch_2]
		213	// Module_1/Project_4 -> [Branch_4]
		214	makeBranch(new IResource[] { project1, project2 }, new CVSTag(version1,
		215	CVSTag.VERSION), new CVSTag(branch1, CVSTag.BRANCH), true);
		216	makeBranch(new IResource[] { project1, project2, project2, project4 },
		217	new CVSTag(version2, CVSTag.VERSION), new CVSTag(branch2,
		218	CVSTag.BRANCH), true);
		219
		220	// verify if tree structure is built from cache
		221	RemoteContentProvider rcp = new RemoteContentProvider();
		222	Object[] categories = rcp.getChildren(getRepositoryRoot());
		223	assertEquals(4, categories.length);
		224	assertTrue(categories[1] instanceof BranchCategory);
		225	Object[] branches = rcp.getChildren(categories[1]);
		226	assertEquals(2, branches.length); // should be [Branch_1] and [Branch_2]
		227	CVSTagElement branch1Element;
		228	CVSTagElement branch2Element;
		229	if (((CVSTagElement) branches[0]).getTag().getName().equals(branch1)) {
		230	branch1Element = (CVSTagElement) branches[0];
		231	branch2Element = (CVSTagElement) branches[1];
		232	} else {
		233	branch1Element = (CVSTagElement) branches[1];
		234	branch2Element = (CVSTagElement) branches[0];
		235	}
		236	Object[] modules = rcp.getChildren(branch1Element);
		237	assertEquals(1, modules.length); // should be [Branch_1]/Module_1
		238	assertEquals(firstModule, ((RemoteResource) modules[0]).getName());
		239	modules = rcp.getChildren(modules[0]);
		240	// should contain:
		241	// [Branch_1]/Module_1/Project_1
		242	// [Branch_1]/Module_1/Module_2
243	assertEquals(2, modules.length);
244	for (int i = 0; i < modules.length; i++) {
245	if (((RemoteResource) (modules[i])).getName().equals(
246	project1.getName())) {
247	// Project_1 should have contents retrieved from CVS
248	assertTrue(rcp.hasChildren(modules[i]));
249	} else if (((RemoteResource) (modules[i])).getName().equals(
250	secondModule)) {
251	// should be only [Branch_1]/Module_1/Module_2/Project_2.
252	// [Branch_1]/Module_1/Module_2/Project_3 should NOT be on the
253	// list, it is not branched with Branch_1
254	Object[] module2Children = rcp.getChildren(modules[i]);
255	assertEquals(1, module2Children.length);
256	assertEquals(project2.getName(),
257	((RemoteResource) module2Children[0]).getName());
258	}
259	}
260	modules = rcp.getChildren(branch2Element);
261	assertEquals(1, modules.length); // should be [Branch_2]/Module_1
262	assertEquals(firstModule, ((RemoteResource) modules[0]).getName());
263	// should contain:
264	// [Branch_2]/Module_1/Project_1
265	// [Branch_2]/Module_1/Module_2
266	// [Branch_2]/Module_1/Project_4
267	modules = rcp.getChildren(modules[0]);
268	assertEquals(3, modules.length);
269	}
162	}	270	}

Added Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/provider/CVSCacheTest.java (+355 lines)
1	/*******************************************************************************
2	* Copyright (c) 2012 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.team.tests.ccvs.core.provider;
12
13	import java.util.Arrays;
14	import java.util.List;
15
16	import junit.framework.Test;
17
18	import org.eclipse.core.resources.IFile;
19	import org.eclipse.core.resources.IProject;
20	import org.eclipse.core.resources.IResource;
21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.team.internal.ccvs.core.CVSException;
23	import org.eclipse.team.internal.ccvs.core.CVSTag;
24	import org.eclipse.team.internal.ccvs.core.ICVSFolder;
25	import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
26	import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
27	import org.eclipse.team.internal.ccvs.ui.repo.RepositoryManager;
28	import org.eclipse.team.internal.ccvs.ui.repo.RepositoryRoot;
29	import org.eclipse.team.tests.ccvs.core.EclipseTest;
30
31	public class CVSCacheTest extends EclipseTest {
32
33	private RepositoryRoot repositoryRoot;
34	private RepositoryManager repositoryManager;
35
36	protected void setUp() throws Exception {
37	super.setUp();
38	repositoryManager = CVSUIPlugin.getPlugin().getRepositoryManager();
39	repositoryRoot = getRepositoryRoot();
40	clearRepositoryRootCache();
41	}
42
43	public static Test suite() {
44	return suite(CVSCacheTest.class);
45	}
46
47	private RepositoryRoot getRepositoryRoot() {
48	Object[] repositoryRoots = repositoryManager.getKnownRepositoryRoots();
49	for (int i = 0; i < repositoryRoots.length; i++) {
50	RepositoryRoot repositoryRoot = (RepositoryRoot) repositoryRoots[i];
51	if (getRepository().equals(repositoryRoot.getRoot())) {
52	return repositoryRoot;
53	}
54	}
55	fail(getRepository() + " not found");
56	return null;
57	}
58
59	private void clearRepositoryRootCache() {
60	String remotePaths[] = repositoryRoot.getKnownRemotePaths();
61	for (int i = 0; i < remotePaths.length; i++) {
62	repositoryRoot.removeTags(remotePaths[i],
63	repositoryRoot.getAllKnownTags(remotePaths[i]));
64	}
65	// verify if tags where cleared
66	assertEquals("Repository cache was not cleaned.", 0,
67	repositoryRoot.getAllKnownTags().length);
68	}
69
70	private IProject createProject(String baseName, String repoPrefix)
71	throws CoreException {
72	// create project
73	IProject project = getUniqueTestProject(baseName);
74	// share project under module
75	shareProject(getRepository(), project,
76	repoPrefix == null ? project.getName()
77	: (repoPrefix + "/" + project.getName()),
78	DEFAULT_MONITOR);
79	assertValidCheckout(project);
80	// add some files
81	addResources(project, new String[] { "file1.txt" }, true);
82	return project;
83	}
84
85	private void assertTags(CVSCacheTestData data) throws CVSException {
86	// Root should contain all known tags
87	List knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
88	assertTrue(knownTags.contains(data.branches[0]));
89	assertTrue(knownTags.contains(data.versions[0]));
90	assertTrue(knownTags.contains(data.branches[1]));
91	assertTrue(knownTags.contains(data.versions[1]));
92	assertTrue(knownTags.contains(data.branches[2]));
93	assertTrue(knownTags.contains(data.versions[2]));
94
95	// Project_1 should contain Branch_1 and Branch_2
96	knownTags = Arrays.asList(repositoryManager
97	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project1)));
98	assertTrue(knownTags.contains(data.branches[0]));
99	assertTrue(knownTags.contains(data.versions[0]));
100	assertTrue(knownTags.contains(data.branches[1]));
101	assertTrue(knownTags.contains(data.versions[1]));
102	assertFalse(knownTags.contains(data.branches[2]));
103	assertFalse(knownTags.contains(data.versions[2]));
104
105	// Project_2 should contain Branch_1 and Branch_3
106	knownTags = Arrays.asList(repositoryManager
107	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project2)));
108	assertTrue(knownTags.contains(data.branches[0]));
109	assertTrue(knownTags.contains(data.versions[0]));
110	assertFalse(knownTags.contains(data.branches[1]));
111	assertFalse(knownTags.contains(data.versions[1]));
112	assertTrue(knownTags.contains(data.branches[2]));
113	assertTrue(knownTags.contains(data.versions[2]));
114	}
115
116	private class CVSCacheTestData {
117	IProject project1; // tagged with Branch_1 and Branch_2
118	IProject project2; // tagged with Branch_1 and Branch_3
119	CVSTag[] branches = new CVSTag[3];
120	CVSTag[] versions = new CVSTag[3];
121
122	private void init(String project1Path, String project2Path)
123	throws CoreException {
124	project1 = createProject("Project_1", project1Path);
125	project2 = createProject("Project_2", project2Path);
126	branches[0] = new CVSTag("Branch_1" + System.currentTimeMillis(),
127	CVSTag.BRANCH);
128	versions[0] = new CVSTag("Root_" + branches[0].getName(),
129	CVSTag.VERSION);
130	branches[1] = new CVSTag("Branch_2" + System.currentTimeMillis(),
131	CVSTag.BRANCH);
132	versions[1] = new CVSTag("Root_" + branches[1].getName(),
133	CVSTag.VERSION);
134	branches[2] = new CVSTag("Branch_3" + System.currentTimeMillis(),
135	CVSTag.BRANCH);
136	versions[2] = new CVSTag("Root_" + branches[2].getName(),
137	CVSTag.VERSION);
138
139	makeBranch(new IResource[] { project1, project2 }, versions[0],
140	branches[0], true);
141	makeBranch(new IResource[] { project1 }, versions[1], branches[1],
142	true);
143	makeBranch(new IResource[] { project2 }, versions[2], branches[2],
144	true);
145	}
146
147	public CVSCacheTestData(String project1Path, String project2Path)
148	throws CoreException {
149	init(project1Path, project2Path);
150	}
151	}
152
153	public void testProjectsOnMainLevel() throws CoreException {
154	CVSCacheTestData data = new CVSCacheTestData(null, null);
155
156	// verify that tags are correct after creating branches
157	assertTags(data);
158
159	// clear the cache and verify that tags are correct after refreshing on
160	// project level
161	clearRepositoryRootCache();
162	repositoryManager.refreshDefinedTags(
163	CVSWorkspaceRoot.getCVSFolderFor(data.project1), true, true,
164	DEFAULT_MONITOR);
165	repositoryManager.refreshDefinedTags(
166	CVSWorkspaceRoot.getCVSFolderFor(data.project2), true, true,
167	DEFAULT_MONITOR);
168	assertTags(data);
169	}
170
171	public void testProjectsInSubmodule() throws CoreException {
172	String submodule = "Submodule_1" + System.currentTimeMillis();
173	CVSCacheTestData data = new CVSCacheTestData(submodule, submodule);
174	ICVSFolder submoduleFolder = repositoryRoot.getRemoteFolder(submodule,
175	null, getMonitor());
176
177	// verify that tags are correct after creating branches
178	assertTags(data);
179
180	// clear the cache and verify that tags are correct after refreshing on
181	// project level
182	clearRepositoryRootCache();
183	repositoryManager.refreshDefinedTags(
184	CVSWorkspaceRoot.getCVSFolderFor(data.project1), true, true,
185	DEFAULT_MONITOR);
186	repositoryManager.refreshDefinedTags(
187	CVSWorkspaceRoot.getCVSFolderFor(data.project2), true, true,
188	DEFAULT_MONITOR);
189	assertTags(data);
190	// verify that parent module has tags from both projects
191	List knownTags = Arrays.asList(repositoryManager
192	.getKnownTags(submoduleFolder));
193	assertTrue(knownTags.contains(data.branches[0]));
194	assertTrue(knownTags.contains(data.versions[0]));
195	assertTrue(knownTags.contains(data.branches[1]));
196	assertTrue(knownTags.contains(data.versions[1]));
197	assertTrue(knownTags.contains(data.branches[2]));
198	assertTrue(knownTags.contains(data.versions[2]));
199
200	// clear the cache, refresh it only for submodule and verify if tags are
201	// correct
202	clearRepositoryRootCache();
203	repositoryManager.refreshDefinedTags(submoduleFolder, true, true,
204	DEFAULT_MONITOR);
205	assertTags(data);
206	// verify that parent module has tags from both projects
207	knownTags = Arrays.asList(repositoryManager
208	.getKnownTags(submoduleFolder));
209	assertTrue(knownTags.contains(data.branches[0]));
210	assertTrue(knownTags.contains(data.versions[0]));
211	assertTrue(knownTags.contains(data.branches[1]));
212	assertTrue(knownTags.contains(data.versions[1]));
213	assertTrue(knownTags.contains(data.branches[2]));
214	assertTrue(knownTags.contains(data.versions[2]));
215	}
216
217	public void testProjectsInTwoSubmodules() throws CoreException {
218	String submodule1 = "Submodule_1" + System.currentTimeMillis();
219	String submodule2 = "Submodule_2" + System.currentTimeMillis();
220	CVSCacheTestData data = new CVSCacheTestData(submodule1, submodule2);
221	ICVSFolder submoduleFolder1 = repositoryRoot.getRemoteFolder(
222	submodule1, null, getMonitor());
223	ICVSFolder submoduleFolder2 = repositoryRoot.getRemoteFolder(
224	submodule2, null, getMonitor());
225
226	// verify that tags are correct after creating branches
227	assertTags(data);
228
229	// clear the cache and verify that tags are correct after refreshing on
230	// project level
231	clearRepositoryRootCache();
232	repositoryManager.refreshDefinedTags(
233	CVSWorkspaceRoot.getCVSFolderFor(data.project1), true, true,
234	DEFAULT_MONITOR);
235	repositoryManager.refreshDefinedTags(
236	CVSWorkspaceRoot.getCVSFolderFor(data.project2), true, true,
237	DEFAULT_MONITOR);
238	assertTags(data);
239	// verify that parent modules have tags from subordinate project, but
240	// not the other project
241	List knownTags = Arrays.asList(repositoryManager
242	.getKnownTags(submoduleFolder1));
243	assertTrue(knownTags.contains(data.branches[0]));
244	assertTrue(knownTags.contains(data.versions[0]));
245	assertTrue(knownTags.contains(data.branches[1]));
246	assertTrue(knownTags.contains(data.versions[1]));
247	assertFalse(knownTags.contains(data.branches[2]));
248	assertFalse(knownTags.contains(data.versions[2]));
249
250	knownTags = Arrays.asList(repositoryManager
251	.getKnownTags(submoduleFolder2));
252	assertTrue(knownTags.contains(data.branches[0]));
253	assertTrue(knownTags.contains(data.versions[0]));
254	assertFalse(knownTags.contains(data.branches[1]));
255	assertFalse(knownTags.contains(data.versions[1]));
256	assertTrue(knownTags.contains(data.branches[2]));
257	assertTrue(knownTags.contains(data.versions[2]));
258
259	// clear the cache, refresh it only one for submodule and verify if tags
260	// are correct
261	clearRepositoryRootCache();
262	repositoryManager.refreshDefinedTags(submoduleFolder1, true, true,
263	DEFAULT_MONITOR);
264
265	// verify that correct tags where added to this submodule
266	knownTags = Arrays.asList(repositoryManager
267	.getKnownTags(submoduleFolder1));
268	assertTrue(knownTags.contains(data.branches[0]));
269	assertTrue(knownTags.contains(data.versions[0]));
270	assertTrue(knownTags.contains(data.branches[1]));
271	assertTrue(knownTags.contains(data.versions[1]));
272	assertFalse(knownTags.contains(data.branches[2]));
273	assertFalse(knownTags.contains(data.versions[2]));
274
275	// verify if only tags from the first submodule are known
276	knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
277	assertTrue(knownTags.contains(data.branches[0]));
278	assertTrue(knownTags.contains(data.versions[0]));
279	assertTrue(knownTags.contains(data.branches[1]));
280	assertTrue(knownTags.contains(data.versions[1]));
281	assertFalse(knownTags.contains(data.branches[2]));
282	assertFalse(knownTags.contains(data.versions[2]));
283
284	// refresh tags for the second submodule and verify if list of tags
285	// where correctly merged
286	repositoryManager.refreshDefinedTags(submoduleFolder2, true, true,
287	DEFAULT_MONITOR);
288	// verify tags for the second submodule
289	knownTags = Arrays.asList(repositoryManager
290	.getKnownTags(submoduleFolder2));
291	assertTrue(knownTags.contains(data.branches[0]));
292	assertTrue(knownTags.contains(data.versions[0]));
293	assertFalse(knownTags.contains(data.branches[1]));
294	assertFalse(knownTags.contains(data.versions[1]));
295	assertTrue(knownTags.contains(data.branches[2]));
296	assertTrue(knownTags.contains(data.versions[2]));
297	// verify if tags are merged correctly
298	assertTags(data);
299	}
300
301	public void testRefreshProjectUsingAutoRefreshFile() throws CoreException {
302	IProject project = createProject("Project_1", (String) null);
303	String autoRefreshFileName = "sampleAuthoRefresh.txt";
304	String notAutoRefreshFileName = "notAutoRefresh.txt";
305	addResources(project, new String[] { autoRefreshFileName,
306	notAutoRefreshFileName }, true);
307	IFile autoRefreshFile = project.getFile(autoRefreshFileName);
308	IFile notAutoRefreshFile = project.getFile(notAutoRefreshFileName);
309	repositoryManager.setAutoRefreshFiles(
310	CVSWorkspaceRoot.getCVSFolderFor(project),
311	new String[] { CVSWorkspaceRoot.getCVSResourceFor(
312	autoRefreshFile).getRepositoryRelativePath() });
313	CVSTag branch1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
314	CVSTag.BRANCH);
315	CVSTag version1 = new CVSTag("Root_" + branch1.getName(),
316	CVSTag.VERSION);
317	// branch the auto refresh file
318	makeBranch(new IResource[] { autoRefreshFile }, version1, branch1, true);
319	CVSTag branch2 = new CVSTag("Branch_2" + System.currentTimeMillis(),
320	CVSTag.BRANCH);
321	CVSTag version2 = new CVSTag("Root_" + branch2.getName(),
322	CVSTag.VERSION);
323	// branch not auto refresh file
324	makeBranch(new IResource[] { notAutoRefreshFile }, version2, branch2,
325	true);
326
327	clearRepositoryRootCache();
328	repositoryManager.refreshDefinedTags(
329	CVSWorkspaceRoot.getCVSFolderFor(project), true, true,
330	DEFAULT_MONITOR);
331
332	// cache should contain branches from auto refresh file, but no branches
333	// from other files
334	List knownTags = Arrays.asList(repositoryManager
335	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
336	assertTrue(knownTags.contains(branch1));
337	assertTrue(knownTags.contains(version1));
338	assertFalse(knownTags.contains(branch2));
339	assertFalse(knownTags.contains(version2));
340
341	}
342
343	public void testProjectWithNoTags() throws CoreException {
344	IProject project = createProject("Project_1", (String) null);
345	List knownTags = Arrays.asList(repositoryManager
346	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
347	assertTrue(knownTags.isEmpty());
348
349	repositoryManager.refreshDefinedTags(
350	CVSWorkspaceRoot.getCVSFolderFor(project), true, true,
351	DEFAULT_MONITOR);
352	assertTrue(knownTags.isEmpty());
353	}
354
355	}