Attachment #212796 for bug #374516

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

View | Details | Raw Unified | Return to bug 374516
Collapse All | Expand All

Lines 2-8 Link Here

(-)a/bundles/org.eclipse.team.cvs.ui/META-INF/MANIFEST.MF (-1 / +1 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %pluginName	3	Bundle-Name: %pluginName
4	Bundle-SymbolicName: org.eclipse.team.cvs.ui; singleton:=true	4	Bundle-SymbolicName: org.eclipse.team.cvs.ui; singleton:=true
5	Bundle-Version: 3.3.302.qualifier	5	Bundle-Version: 3.3.303.qualifier
6	Bundle-Activator: org.eclipse.team.internal.ccvs.ui.CVSUIPlugin	6	Bundle-Activator: org.eclipse.team.internal.ccvs.ui.CVSUIPlugin
7	Bundle-Vendor: %providerName	7	Bundle-Vendor: %providerName
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin




/*******************************************************************************
 * 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) }), 100);
			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, 50));
		} finally {
			monitor.done();
		}
	}

    public void fetchDeferredChildren(Object o, IElementCollector collector, IProgressMonitor monitor) {
    	// If it's not a folder, return an empty array
		if (!(o instanceof ICVSRemoteFolder)) {
			collector.add(new Object[0], monitor);
		}
		try {
			monitor = Policy.monitorFor(monitor);
			monitor.beginTask(NLS.bind(
					CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
					new String[] { getLabel(o) }), 100);
			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,
					folder, collector);
			operation.run(Policy.subMonitorFor(monitor, 50));
		} 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.
	 *
	 * NOTE: Resources are cached only for tags of type CVSTag.Branch and
	 * CVSTag.Version. Other types of tags will always return empty list.
	 *
	 * @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

	
	ICVSRepositoryLocation root;
	String name;
	TagCacheEntry rootTagCacheEntry = new TagCacheEntry(Path.ROOT, null);
	Map versionAndBranchTags = new HashMap();
	// 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 {
		IPath path;
		// Set of tags found for this path
		private 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(IPath path, TagCacheEntry parent) {
			this.path = path;
			this.parent = parent;
			accessed();
		}

		public Set getTags() {
			accessed();
			return tags;
		}

		public Iterator getChildrenIterator() {
			return this.children.values().iterator();
		}

		public boolean isEmpty() {
			return getTags().isEmpty() && children.isEmpty();
		}

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

            int days = hours / 24;
            return days > CACHE_LIFESPAN_IN_DAYS;
        }

		private void accessed() {
			lastAccessTime = System.currentTimeMillis();
		}
	}
	
	public RepositoryRoot(ICVSRepositoryLocation root) {

	 * 
	 * 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);

		
		// 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) {
				Set parentTags = new HashSet();
				addAllKnownTagsForParents(entry, parentTags);
				if (!parentTags.contains(tags[i])) {
					entry.getTags().add(tags[i]);
					removeTagFromChildrenCacheEntries(entry, 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) {
			removeTagsFromChildrenCacheEntries(entry, tags);
		TagCacheEntry entry = (TagCacheEntry)versionAndBranchTags.get(name);
		if (entry == null) {
			return;
		}

		// remove tags from all parents of this path
		entry = getKnownParentTagCacheEntryFor(remotePath);
		for (int i = 0; i < tags.length; i++) {
			if (entry.getTags().contains(tags[i])) {
				entry.getTags().remove(tags[i]);
				continue;
			}
			TagCacheEntry currentEntry = entry;
			while (currentEntry.parent != null) {
				if (currentEntry.parent.getTags().contains(tags[i])) {
					// remove tag from parent and add it to siblings
					currentEntry.parent.getTags().remove(tags[i]);
					Iterator siblingIterator = currentEntry.parent
							.getChildrenIterator();
					while (siblingIterator.hasNext()) {
						TagCacheEntry sibling = (TagCacheEntry) siblingIterator
								.next();
						if (!sibling.equals(currentEntry)) {
							sibling.getTags().add(tags[i]);
						}
					}
					break;
				} else {
					currentEntry = currentEntry.parent;
				}
			}
		}
		if (entry.isEmpty()) {
			removeTagCacheEntry(entry);
		}
	}

	/**

	 * @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) {
				Set tagsSet = new HashSet();
				folder.fetchChildren(Policy.subMonitorFor(monitor, 10));
				ICVSResource[] children = folder
						.members(ICVSFolder.FOLDER_MEMBERS);
				for (int i = 0; i < children.length; i++) {
					tagsSet.addAll(Arrays.asList(refreshDefinedTags(
							(ICVSFolder) children[i], recurse, Policy
									.subMonitorFor(monitor,
											100 / children.length))));
				}
				tags = (CVSTag[]) tagsSet.toArray(new CVSTag[tagsSet.size()]);
			}
			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)),
					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 removeTagsFromChildrenCacheEntries(TagCacheEntry entry,
			CVSTag[] tags) {
		for (int i = 0; i < tags.length; i++) {
			removeTagFromChildrenCacheEntries(entry, tags[i]);
		}
		entry.getTags().removeAll(Arrays.asList(tags));
		if (entry.isEmpty()) {
			// remove this entry when the last tags where removed
			// keep the entry if there are any children that have tags
			removeTagCacheEntry(entry);
		}
	}

	private void removeTagCacheEntry(TagCacheEntry entry) {
		if (entry.parent == null) {
			// We cannot remove root tag cache entry
			return;
		}
		Map newParentChildren = new HashMap();
		newParentChildren.putAll(entry.parent.children);
		newParentChildren.remove(entry.path.lastSegment());
		entry.parent.children = newParentChildren;
		if (entry.parent.isEmpty()) {
			// remove parents if they no longer carry any value
			removeTagCacheEntry(entry.parent);
		}
	}

	private void removeTagFromChildrenCacheEntries(TagCacheEntry entry,
			CVSTag tag) {
		Iterator childrenIterator = entry.getChildrenIterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			removeTagFromChildrenCacheEntries(child, tag);
			child.getTags().remove(tag);
			if (child.isEmpty()) {
				// remove this entry when the last tag was removed
				// keep the entry if there are any children that have tags
				removeTagCacheEntry(child);
			}
		}
	}
	
	/**

				attributes.put(RepositoriesViewContentHandler.TYPE_ATTRIBUTE, RepositoriesViewContentHandler.DEFINED_MODULE_TYPE);
			}
			attributes.put(RepositoriesViewContentHandler.PATH_ATTRIBUTE, name);
			TagCacheEntry entry = getTagCacheEntryFor(path, false);
			boolean writeOutTags = entry != null && !entry.isExpired();
			if (writeOutTags)
			    attributes.put(RepositoriesViewContentHandler.LAST_ACCESS_TIME_ATTRIBUTE, Long.toString(entry.lastAccessTime));
			writer.startTag(RepositoriesViewContentHandler.MODULE_TAG, attributes, true);
			if (writeOutTags) {
				Iterator tagIt = entry.getTags().iterator();
				while (tagIt.hasNext()) {
					CVSTag tag = (CVSTag)tagIt.next();
					writeATag(writer, attributes, tag, RepositoriesViewContentHandler.TAG_TAG);

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

	private void addAllKnownTagsForParents(TagCacheEntry entry, Set tags) {
		if (entry.parent != null) {
			addAllKnownTagsForParents(entry.parent, tags);
		}
		tags.addAll(entry.getTags());
	}

	private void addAllKnownTagsForChildren(TagCacheEntry entry, Set tags) {
		Iterator childrenIterator = entry.getChildrenIterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			addAllKnownTagsForChildren(child, tags);
		}
		tags.addAll(entry.getTags());
	}

	/**
	 * Method getKnownTags.
	 * @param remotePath
	 * @return CVSTag[]
	 */
	public CVSTag[] getAllKnownTags(String remotePath) {
		Set tags = new HashSet();
		addAllKnownTagsForParents(getKnownParentTagCacheEntryFor(remotePath),
				tags);
		TagCacheEntry entry = getTagCacheEntryFor(remotePath, false);
		if (entry != null) {
			addAllKnownTagsForChildren(entry, tags);
			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 = new HashSet();
		addAllKnownTagsForChildren(rootTagCacheEntry, tags);
		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.getChildrenIterator();
		while (childrenIterator.hasNext()) {
			TagCacheEntry child = (TagCacheEntry) childrenIterator.next();
			Set childTags = new HashSet();
			addAllKnownTagsForChildren(child, childTags);
			if (childTags.contains(tag)) {
				paths.add(child.path.toString());
			}
		}
		return (String[]) paths.toArray(new String[paths.size()]);
	}

	private Set getKnownRemotePaths(TagCacheEntry entry) {
		Set paths = new HashSet();
		Iterator childrenIterator = entry.getChildrenIterator();
		while (childrenIterator.hasNext()) {
			paths.addAll(getKnownRemotePaths((TagCacheEntry) childrenIterator
					.next()));
		}
		paths.add(entry.path.toString());
		return paths;
	}

	public String[] getKnownRemotePaths() {
		Set paths = getKnownRemotePaths(rootTagCacheEntry);
		paths.addAll(versionAndBranchTags.keySet());
		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 1-5 Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/provider/AllTestsProvider.java (-1 / +2 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 34-39 Link Here
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(RepositoryRootTest.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.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.team.core.TeamException;
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 RepositoryRootTest extends EclipseTest {

	private RepositoryRoot repositoryRoot;
	private RepositoryManager repositoryManager;

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

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

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

	private CVSTag[] refreshTags(IProject project) throws TeamException {
		return refreshTags(CVSWorkspaceRoot.getCVSFolderFor(project));
	}

	private CVSTag[] refreshTags(ICVSFolder folder) throws TeamException {
		return repositoryManager.refreshDefinedTags(folder, true, true,
				DEFAULT_MONITOR);
	}

	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(List knownTags, CVSTag[] tagsToHave,
			CVSTag[] tagsNotToHave) {
		for (int i = 0; i < tagsToHave.length; i++) {
			assertTrue("Missing tag " + tagsToHave[i].getName(),
					knownTags.contains(tagsToHave[i]));
		}
		for (int i = 0; i < tagsNotToHave.length; i++) {
			assertFalse("Extraneous tag " + tagsNotToHave[i].getName(),
					knownTags.contains(tagsNotToHave[i]));
		}
	}

	private void assertProjectTags(CVSCacheTestData data) throws CVSException {
		// Root should contain all known tags
		List knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
		assertTags(knownTags,
				new CVSTag[] { data.branch_1, data.branch_2, data.branch_3,
						data.version_1, data.version_2, data.version_3 },
				new CVSTag[0]);

		// Project_1 should contain Branch_1 and Branch_2
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project1)));
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
				data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
				data.version_3 });
		// Project_2 should contain Branch_1 and Branch_3
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project2)));
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_3,
				data.version_1, data.version_3 }, new CVSTag[] { data.branch_2,
				data.version_2 });
	}

	private class CVSCacheTestData {
		IProject project1; // tagged with Branch_1 and Branch_2
		IProject project2; // tagged with Branch_1 and Branch_3
		CVSTag branch_1;
		CVSTag branch_2;
		CVSTag branch_3;
		CVSTag version_1;
		CVSTag version_2;
		CVSTag version_3;

		private void init(String project1Path, String project2Path)
				throws CoreException {
			project1 = createProject("Project_1", project1Path);
			project2 = createProject("Project_2", project2Path);
			branch_1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
					CVSTag.BRANCH);
			version_1 = new CVSTag("Root_" + branch_1.getName(), CVSTag.VERSION);
			branch_2 = new CVSTag("Branch_2" + System.currentTimeMillis(),
					CVSTag.BRANCH);
			version_2 = new CVSTag("Root_" + branch_2.getName(), CVSTag.VERSION);
			branch_3 = new CVSTag("Branch_3" + System.currentTimeMillis(),
					CVSTag.BRANCH);
			version_3 = new CVSTag("Root_" + branch_3.getName(), CVSTag.VERSION);

			makeBranch(new IResource[] { project1, project2 }, version_1,
					branch_1, true);
			makeBranch(new IResource[] { project1 }, version_2, branch_2, true);
			makeBranch(new IResource[] { project2 }, version_3, branch_3, true);
		}

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

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

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

		clearRepositoryRootCache();
		refreshTags(data.project1);
		refreshTags(data.project2);
		assertProjectTags(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
		assertProjectTags(data);

		clearRepositoryRootCache();
		refreshTags(data.project1);
		refreshTags(data.project2);
		assertProjectTags(data);
		// verify that parent module has tags from both projects
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder));
		assertTags(knownTags,
				new CVSTag[] { data.branch_1, data.branch_2, data.branch_3,
						data.version_1, data.version_2, data.version_3 },
				new CVSTag[0]);

		clearRepositoryRootCache();
		refreshTags(submoduleFolder);
		assertProjectTags(data);
		// verify that parent module has tags from both projects
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder));
		assertTags(knownTags,
				new CVSTag[] { data.branch_1, data.branch_2, data.branch_3,
						data.version_1, data.version_2, data.version_3 },
				new CVSTag[0]);
	}

	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
		assertProjectTags(data);

		clearRepositoryRootCache();
		refreshTags(data.project1);
		refreshTags(data.project2);
		assertProjectTags(data);
		// verify that parent modules have tags from subordinate project, but
		// not the other project
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder1));
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
				data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
				data.version_3 });
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder2));
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_3,
				data.version_1, data.version_3 }, new CVSTag[] { data.branch_2,
				data.version_2 });
		// clear the cache, refresh it only one for submodule and verify if tags
		// are correct
		clearRepositoryRootCache();
		refreshTags(submoduleFolder1);

		// verify that correct tags where added to this submodule
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder1));
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
				data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
				data.version_3 });
		// verify if only tags from the first submodule are known
		knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
				data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
				data.version_3 });

		refreshTags(submoduleFolder2);
		// verify tags for the second submodule
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(submoduleFolder2));
		assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_3,
				data.version_1, data.version_3 }, new CVSTag[] { data.branch_2,
				data.version_2 });
		// verify if tags are merged correctly
		assertProjectTags(data);
	}

	public void testNestedProjects() throws CoreException {
		IProject superProject = createProject("SuperProject", (String) null);
		CVSTag superProjectBranch = new CVSTag("Branch_"
				+ superProject.getName(), CVSTag.BRANCH);
		CVSTag superProjectVersion = new CVSTag("Root_"
				+ superProjectBranch.getName(), CVSTag.VERSION);
		makeBranch(new IResource[] { superProject }, superProjectVersion,
				superProjectBranch, true);
		// subProject1 and subProject2 are nested in superProject
		// each of them has its own tags
		IProject subProject1 = createProject("SubProject_1",
				superProject.getName());
		CVSTag subProject1Branch = new CVSTag(
				"Branch_" + subProject1.getName(), CVSTag.BRANCH);
		CVSTag subProject1Version = new CVSTag("Root_"
				+ subProject1Branch.getName(), CVSTag.VERSION);
		makeBranch(new IResource[] { subProject1 }, subProject1Version,
				subProject1Branch, true);
		IProject subProject2 = createProject("SubProject_2",
				superProject.getName());
		CVSTag subProject2Branch = new CVSTag(
				"Branch_" + subProject2.getName(), CVSTag.BRANCH);
		CVSTag subProject2Version = new CVSTag("Root_"
				+ subProject2Branch.getName(), CVSTag.VERSION);
		makeBranch(new IResource[] { subProject2 }, subProject2Version,
				subProject2Branch, true);
		// check if subProjects have tags from superProject but not tags from
		// each other, check if superProject has tags from all subProjects
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(superProject)));
		assertTags(knownTags, new CVSTag[] { superProjectBranch,
				superProjectVersion, subProject1Branch, subProject1Version,
				subProject2Branch, subProject2Version }, new CVSTag[0]);
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject1)));
		assertTags(knownTags, new CVSTag[] { superProjectBranch,
				superProjectVersion, subProject1Branch, subProject1Version },
				new CVSTag[] { subProject2Branch, subProject2Version });
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject2)));
		assertTags(knownTags, new CVSTag[] { superProjectBranch,
				superProjectVersion, subProject2Branch, subProject2Version },
				new CVSTag[] { subProject1Branch, subProject1Version });
		// remove tag from one of the subProjects, check if it was not removed
		// from the other subProject, check if superProject still has this tag
		repositoryManager.removeTags(
				CVSWorkspaceRoot.getCVSFolderFor(subProject1), new CVSTag[] {
						superProjectBranch, superProjectVersion });
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(superProject)));
		assertTags(knownTags, new CVSTag[] { superProjectBranch,
				superProjectVersion, subProject1Branch, subProject1Version,
				subProject2Branch, subProject2Version }, new CVSTag[0]);
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject1)));
		assertTags(knownTags, new CVSTag[] { subProject1Branch,
				subProject1Version }, new CVSTag[] { subProject2Branch,
				subProject2Version });
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject2)));
		assertTags(knownTags, new CVSTag[] { superProjectBranch,
				superProjectVersion, subProject2Branch, subProject2Version },
				new CVSTag[] { subProject1Branch, subProject1Version });
	}

	public void testTagsForSubfolder() throws TeamException, CoreException {
		IProject project = createProject("Project_1", (String) null);
		String folderName = "testFolder";
		addResources(project, new String[] { folderName + "/",
				folderName + "/testFile.txt" }, true);
		IFolder folder = project.getFolder(folderName);
		CVSTag branch1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
				CVSTag.BRANCH);
		CVSTag version1 = new CVSTag("Root_" + branch1.getName(),
				CVSTag.VERSION);
		makeBranch(new IResource[] { project }, version1, branch1, true);
		// verify if project's tags are known for subfolder
		ICVSFolder cvsFolder = CVSWorkspaceRoot.getCVSFolderFor(folder);
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(cvsFolder));
		assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[0]);
		// verify if removing tags from subfolder is correctly handled
		repositoryManager.removeTags(cvsFolder, new CVSTag[] { branch1,
				version1 });
		knownTags = Arrays.asList(repositoryManager.getKnownTags(cvsFolder));
		assertTags(knownTags, new CVSTag[0], new CVSTag[] { branch1, version1 });
		// verify if after refreshing tags are back for both project and its
		// subfolder
		refreshTags(cvsFolder);
		knownTags = Arrays.asList(repositoryManager.getKnownTags(cvsFolder));
		assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[0]);
		knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
		assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[0]);
	}

	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();
		refreshTags(project);

		// cache should contain branches from auto refresh file, but no branches
		// from other files
		List knownTags = Arrays.asList(repositoryManager
				.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
		assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[] {
				branch2, version2 });
	}

	public void testProjectWithNoTags() throws CoreException {
		IProject project = createProject("Project_1", (String) null);
		CVSTag knownTags[] = repositoryManager.getKnownTags(CVSWorkspaceRoot
				.getCVSFolderFor(project));
		assertEquals(0, knownTags.length);
		knownTags = refreshTags(project);
		assertEquals(0, knownTags.length);
	}

}




/*******************************************************************************
 * 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
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.tests.ccvs.ui;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.internal.ccvs.core.CVSTag;
import org.eclipse.team.internal.ccvs.core.resources.RemoteFolder;
import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
import org.eclipse.team.internal.ccvs.ui.model.AllRootsElement;
import org.eclipse.team.internal.ccvs.ui.model.BranchCategory;
import org.eclipse.team.internal.ccvs.ui.model.CVSTagElement;
import org.eclipse.team.internal.ccvs.ui.model.RemoteContentProvider;
import org.eclipse.team.internal.ccvs.ui.model.RemoteModule;
import org.eclipse.team.internal.ccvs.ui.model.VersionCategory;
import org.eclipse.team.internal.ccvs.ui.repo.RepositoryRoot;
import org.eclipse.team.tests.ccvs.core.CVSTestSetup;
import org.eclipse.team.tests.ccvs.core.EclipseTest;

public class RepositoriesViewTests extends EclipseTest {

	public RepositoriesViewTests(String testName) {
		super(testName);
	}

	protected void setUp() throws Exception {
		super.setUp();
		// clear repository root cache
		RepositoryRoot repositoryRoot = getRepositoryRoot();
		String remotePaths[] = repositoryRoot.getKnownRemotePaths();
		for (int i = 0; i < remotePaths.length; i++) {
			repositoryRoot.removeTags(remotePaths[i],
					repositoryRoot.getAllKnownTags(remotePaths[i]));
		}
	}

	private RepositoryRoot getRepositoryRoot() {
		RemoteContentProvider rcp = new RemoteContentProvider();
		AllRootsElement are = new AllRootsElement();
		Object[] repositoryRoots = rcp.getElements(are);
		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;
	}

	public static Test suite() {
		String testName = System.getProperty("eclipse.cvs.testName");
		if (testName == null) {
			TestSuite suite = new TestSuite(RepositoriesViewTests.class);
			return new CVSTestSetup(suite);
		} else {
			return new CVSTestSetup(new RepositoriesViewTests(testName));
		}
	}

	public void testBranchSubmoduleChildren() throws TeamException,
			CoreException {

		String time = Long.toString(System.currentTimeMillis());
		String moduleName = "TestBranchSubmoduleChildrenTestModule" + time;
		String branchName = "TestBranchSubmoduleChildrenBranch" + time;
		String versionName = "Root_" + branchName;

		// create project
		IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");
		// 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);

		// check if module is the only branch child
		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(1, branches.length);
		assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
				.getName());
		Object[] modules = rcp.getChildren(branches[0]);
		assertEquals(1, modules.length);
		assertEquals(moduleName, ((RemoteResource) modules[0]).getName());

		// 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 {

		String time = Long.toString(System.currentTimeMillis());
		String moduleName = "TestTagSubmoduleChildrenTestModule" + time;
		String versionName = "TestTagSubmoduleChildrenBranch" + time;

		// create project
		IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");
		// share project under module
		shareProject(getRepository(), project,
				moduleName + "/" + project.getName(), DEFAULT_MONITOR);
		assertValidCheckout(project);

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

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

		tagProject(project, tag, true);


		RemoteContentProvider rcp = new RemoteContentProvider();
		Object[] categories = rcp.getChildren(getRepositoryRoot());
		assertEquals(4, categories.length);

		// check if version exists for module
		assertTrue(categories[2] instanceof VersionCategory);
		Object[] modules = rcp.getChildren(categories[2]);
		for (int i = 0; i < modules.length; i++) {
			if (modules[i] instanceof RemoteModule
					&& ((RemoteModule) (modules[i])).getCVSResource().getName()
							.equals(moduleName)) {
				Object folders[] = rcp.getChildren(modules[i]);
				assertEquals(1, folders.length);
				assertEquals(versionName, ((RemoteFolder) folders[0]).getTag()
						.getName());
				return;
			}
		}
		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 374516

Lines 1-5 Link Here

(-)a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/repo/RepositoryManager.java (-16 / +64 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	* NOTE: Resources are cached only for tags of type CVSTag.Branch and
		244	* CVSTag.Version. Other types of tags will always return empty list.
		245	*
		246	* @param location
		247	* CVS repository location
		248	* @param parentFolder
		249	* folder to check tags for
		250	* @param tag
		251	* @param monitor
		252	* @return a list of remote resources that are known to contain given tag or
		253	* empty list if resources should be retrieved from the repository
		254	* @throws CVSException
		255	*/
		256	public ICVSRemoteResource[] getCachedChildrenForTag(
		257	ICVSRepositoryLocation location, ICVSRemoteFolder parentFolder,
		258	CVSTag tag, IProgressMonitor monitor) throws CVSException {
		259	if (tag == null \|\| tag.getType() == CVSTag.HEAD
		260	\|\| tag.getType() == CVSTag.DATE) {
		261	// folders are kept in cache only for tags and versions
		262	return new ICVSRemoteResource[0];
		263	}
		264	monitor = Policy.monitorFor(monitor);
		265	Set result = new HashSet();
		266	RepositoryRoot root = getRepositoryRootFor(location);
		267	// if remote folder is null return the subfolders of repository root
		268	String[] paths = root.getRemoteChildrenForTag(
		269	parentFolder == null ? null : RepositoryRoot
		270	.getRemotePathFor(parentFolder), tag);
		271	monitor.beginTask(NLS
		272	.bind(CVSUIMessages.RemoteFolderElement_fetchingRemoteChildren,
		273	new String[] { NLS.bind(
		274	CVSUIMessages.RemoteFolderElement_nameAndTag,
		275	new String[] { parentFolder.getName(),
		276	tag.getName() }) }), 10 * paths.length);
		277	try {
		278	for (int i = 0; i < paths.length; i++) {
		279	String path = paths[i];
		280	ICVSRemoteFolder remote = root.getRemoteFolder(path, tag,
		281	Policy.subMonitorFor(monitor, 10));
		282	result.add(remote);
		283	}
		284	return (ICVSRemoteResource[]) result
		285	.toArray(new ICVSRemoteResource[result.size()]);
		286	} finally {
		287	monitor.done();
		288	}
		289	}
242		290
243	/*	291	/*
244	* Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file	292	* Fetches tags from auto-refresh files if they exist. Then fetches tags from the user defined auto-refresh file

Added Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/core/provider/RepositoryRootTest.java (+397 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.IFolder;
20	import org.eclipse.core.resources.IProject;
21	import org.eclipse.core.resources.IResource;
22	import org.eclipse.core.runtime.CoreException;
23	import org.eclipse.team.core.TeamException;
24	import org.eclipse.team.internal.ccvs.core.CVSException;
25	import org.eclipse.team.internal.ccvs.core.CVSTag;
26	import org.eclipse.team.internal.ccvs.core.ICVSFolder;
27	import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
28	import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
29	import org.eclipse.team.internal.ccvs.ui.repo.RepositoryManager;
30	import org.eclipse.team.internal.ccvs.ui.repo.RepositoryRoot;
31	import org.eclipse.team.tests.ccvs.core.EclipseTest;
32
33	public class RepositoryRootTest extends EclipseTest {
34
35	private RepositoryRoot repositoryRoot;
36	private RepositoryManager repositoryManager;
37
38	protected void setUp() throws Exception {
39	super.setUp();
40	repositoryManager = CVSUIPlugin.getPlugin().getRepositoryManager();
41	repositoryRoot = repositoryManager
42	.getRepositoryRootFor(getRepository());
43	clearRepositoryRootCache();
44	}
45
46	public static Test suite() {
47	return suite(RepositoryRootTest.class);
48	}
49
50	private void clearRepositoryRootCache() {
51	String remotePaths[] = repositoryRoot.getKnownRemotePaths();
52	for (int i = 0; i < remotePaths.length; i++) {
53	repositoryRoot.removeTags(remotePaths[i],
54	repositoryRoot.getAllKnownTags(remotePaths[i]));
55	}
56	assertEquals("Repository cache was not cleaned.", 0,
57	repositoryRoot.getAllKnownTags().length);
58	}
59
60	private CVSTag[] refreshTags(IProject project) throws TeamException {
61	return refreshTags(CVSWorkspaceRoot.getCVSFolderFor(project));
62	}
63
64	private CVSTag[] refreshTags(ICVSFolder folder) throws TeamException {
65	return repositoryManager.refreshDefinedTags(folder, true, true,
66	DEFAULT_MONITOR);
67	}
68
69	private IProject createProject(String baseName, String repoPrefix)
70	throws CoreException {
71	// create project
72	IProject project = getUniqueTestProject(baseName);
73	// share project under module
74	shareProject(getRepository(), project,
75	repoPrefix == null ? project.getName()
76	: (repoPrefix + "/" + project.getName()),
77	DEFAULT_MONITOR);
78	assertValidCheckout(project);
79	// add some files
80	addResources(project, new String[] { "file1.txt" }, true);
81	return project;
82	}
83
84	private void assertTags(List knownTags, CVSTag[] tagsToHave,
85	CVSTag[] tagsNotToHave) {
86	for (int i = 0; i < tagsToHave.length; i++) {
87	assertTrue("Missing tag " + tagsToHave[i].getName(),
88	knownTags.contains(tagsToHave[i]));
89	}
90	for (int i = 0; i < tagsNotToHave.length; i++) {
91	assertFalse("Extraneous tag " + tagsNotToHave[i].getName(),
92	knownTags.contains(tagsNotToHave[i]));
93	}
94	}
95
96	private void assertProjectTags(CVSCacheTestData data) throws CVSException {
97	// Root should contain all known tags
98	List knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
99	assertTags(knownTags,
100	new CVSTag[] { data.branch_1, data.branch_2, data.branch_3,
101	data.version_1, data.version_2, data.version_3 },
102	new CVSTag[0]);
103
104	// Project_1 should contain Branch_1 and Branch_2
105	knownTags = Arrays.asList(repositoryManager
106	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project1)));
107	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
108	data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
109	data.version_3 });
110	// Project_2 should contain Branch_1 and Branch_3
111	knownTags = Arrays.asList(repositoryManager
112	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(data.project2)));
113	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_3,
114	data.version_1, data.version_3 }, new CVSTag[] { data.branch_2,
115	data.version_2 });
116	}
117
118	private class CVSCacheTestData {
119	IProject project1; // tagged with Branch_1 and Branch_2
120	IProject project2; // tagged with Branch_1 and Branch_3
121	CVSTag branch_1;
122	CVSTag branch_2;
123	CVSTag branch_3;
124	CVSTag version_1;
125	CVSTag version_2;
126	CVSTag version_3;
127
128	private void init(String project1Path, String project2Path)
129	throws CoreException {
130	project1 = createProject("Project_1", project1Path);
131	project2 = createProject("Project_2", project2Path);
132	branch_1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
133	CVSTag.BRANCH);
134	version_1 = new CVSTag("Root_" + branch_1.getName(), CVSTag.VERSION);
135	branch_2 = new CVSTag("Branch_2" + System.currentTimeMillis(),
136	CVSTag.BRANCH);
137	version_2 = new CVSTag("Root_" + branch_2.getName(), CVSTag.VERSION);
138	branch_3 = new CVSTag("Branch_3" + System.currentTimeMillis(),
139	CVSTag.BRANCH);
140	version_3 = new CVSTag("Root_" + branch_3.getName(), CVSTag.VERSION);
141
142	makeBranch(new IResource[] { project1, project2 }, version_1,
143	branch_1, true);
144	makeBranch(new IResource[] { project1 }, version_2, branch_2, true);
145	makeBranch(new IResource[] { project2 }, version_3, branch_3, true);
146	}
147
148	public CVSCacheTestData(String project1Path, String project2Path)
149	throws CoreException {
150	init(project1Path, project2Path);
151	}
152	}
153
154	public void testProjectsAtRoot() throws CoreException {
155	CVSCacheTestData data = new CVSCacheTestData(null, null);
156
157	// verify that tags are correct after creating branches
158	assertProjectTags(data);
159
160	clearRepositoryRootCache();
161	refreshTags(data.project1);
162	refreshTags(data.project2);
163	assertProjectTags(data);
164	}
165
166	public void testProjectsInSubmodule() throws CoreException {
167	String submodule = "Submodule_1" + System.currentTimeMillis();
168	CVSCacheTestData data = new CVSCacheTestData(submodule, submodule);
169	ICVSFolder submoduleFolder = repositoryRoot.getRemoteFolder(submodule,
170	null, getMonitor());
171
172	// verify that tags are correct after creating branches
173	assertProjectTags(data);
174
175	clearRepositoryRootCache();
176	refreshTags(data.project1);
177	refreshTags(data.project2);
178	assertProjectTags(data);
179	// verify that parent module has tags from both projects
180	List knownTags = Arrays.asList(repositoryManager
181	.getKnownTags(submoduleFolder));
182	assertTags(knownTags,
183	new CVSTag[] { data.branch_1, data.branch_2, data.branch_3,
184	data.version_1, data.version_2, data.version_3 },
185	new CVSTag[0]);
186
187	clearRepositoryRootCache();
188	refreshTags(submoduleFolder);
189	assertProjectTags(data);
190	// verify that parent module has tags from both projects
191	knownTags = Arrays.asList(repositoryManager
192	.getKnownTags(submoduleFolder));
193	assertTags(knownTags,
194	new CVSTag[] { data.branch_1, data.branch_2, data.branch_3,
195	data.version_1, data.version_2, data.version_3 },
196	new CVSTag[0]);
197	}
198
199	public void testProjectsInTwoSubmodules() throws CoreException {
200	String submodule1 = "Submodule_1" + System.currentTimeMillis();
201	String submodule2 = "Submodule_2" + System.currentTimeMillis();
202	CVSCacheTestData data = new CVSCacheTestData(submodule1, submodule2);
203	ICVSFolder submoduleFolder1 = repositoryRoot.getRemoteFolder(
204	submodule1, null, getMonitor());
205	ICVSFolder submoduleFolder2 = repositoryRoot.getRemoteFolder(
206	submodule2, null, getMonitor());
207
208	// verify that tags are correct after creating branches
209	assertProjectTags(data);
210
211	clearRepositoryRootCache();
212	refreshTags(data.project1);
213	refreshTags(data.project2);
214	assertProjectTags(data);
215	// verify that parent modules have tags from subordinate project, but
216	// not the other project
217	List knownTags = Arrays.asList(repositoryManager
218	.getKnownTags(submoduleFolder1));
219	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
220	data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
221	data.version_3 });
222	knownTags = Arrays.asList(repositoryManager
223	.getKnownTags(submoduleFolder2));
224	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_3,
225	data.version_1, data.version_3 }, new CVSTag[] { data.branch_2,
226	data.version_2 });
227	// clear the cache, refresh it only one for submodule and verify if tags
228	// are correct
229	clearRepositoryRootCache();
230	refreshTags(submoduleFolder1);
231
232	// verify that correct tags where added to this submodule
233	knownTags = Arrays.asList(repositoryManager
234	.getKnownTags(submoduleFolder1));
235	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
236	data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
237	data.version_3 });
238	// verify if only tags from the first submodule are known
239	knownTags = Arrays.asList(repositoryRoot.getAllKnownTags());
240	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_2,
241	data.version_1, data.version_2 }, new CVSTag[] { data.branch_3,
242	data.version_3 });
243
244	refreshTags(submoduleFolder2);
245	// verify tags for the second submodule
246	knownTags = Arrays.asList(repositoryManager
247	.getKnownTags(submoduleFolder2));
248	assertTags(knownTags, new CVSTag[] { data.branch_1, data.branch_3,
249	data.version_1, data.version_3 }, new CVSTag[] { data.branch_2,
250	data.version_2 });
251	// verify if tags are merged correctly
252	assertProjectTags(data);
253	}
254
255	public void testNestedProjects() throws CoreException {
256	IProject superProject = createProject("SuperProject", (String) null);
257	CVSTag superProjectBranch = new CVSTag("Branch_"
258	+ superProject.getName(), CVSTag.BRANCH);
259	CVSTag superProjectVersion = new CVSTag("Root_"
260	+ superProjectBranch.getName(), CVSTag.VERSION);
261	makeBranch(new IResource[] { superProject }, superProjectVersion,
262	superProjectBranch, true);
263	// subProject1 and subProject2 are nested in superProject
264	// each of them has its own tags
265	IProject subProject1 = createProject("SubProject_1",
266	superProject.getName());
267	CVSTag subProject1Branch = new CVSTag(
268	"Branch_" + subProject1.getName(), CVSTag.BRANCH);
269	CVSTag subProject1Version = new CVSTag("Root_"
270	+ subProject1Branch.getName(), CVSTag.VERSION);
271	makeBranch(new IResource[] { subProject1 }, subProject1Version,
272	subProject1Branch, true);
273	IProject subProject2 = createProject("SubProject_2",
274	superProject.getName());
275	CVSTag subProject2Branch = new CVSTag(
276	"Branch_" + subProject2.getName(), CVSTag.BRANCH);
277	CVSTag subProject2Version = new CVSTag("Root_"
278	+ subProject2Branch.getName(), CVSTag.VERSION);
279	makeBranch(new IResource[] { subProject2 }, subProject2Version,
280	subProject2Branch, true);
281	// check if subProjects have tags from superProject but not tags from
282	// each other, check if superProject has tags from all subProjects
283	List knownTags = Arrays.asList(repositoryManager
284	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(superProject)));
285	assertTags(knownTags, new CVSTag[] { superProjectBranch,
286	superProjectVersion, subProject1Branch, subProject1Version,
287	subProject2Branch, subProject2Version }, new CVSTag[0]);
288	knownTags = Arrays.asList(repositoryManager
289	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject1)));
290	assertTags(knownTags, new CVSTag[] { superProjectBranch,
291	superProjectVersion, subProject1Branch, subProject1Version },
292	new CVSTag[] { subProject2Branch, subProject2Version });
293	knownTags = Arrays.asList(repositoryManager
294	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject2)));
295	assertTags(knownTags, new CVSTag[] { superProjectBranch,
296	superProjectVersion, subProject2Branch, subProject2Version },
297	new CVSTag[] { subProject1Branch, subProject1Version });
298	// remove tag from one of the subProjects, check if it was not removed
299	// from the other subProject, check if superProject still has this tag
300	repositoryManager.removeTags(
301	CVSWorkspaceRoot.getCVSFolderFor(subProject1), new CVSTag[] {
302	superProjectBranch, superProjectVersion });
303	knownTags = Arrays.asList(repositoryManager
304	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(superProject)));
305	assertTags(knownTags, new CVSTag[] { superProjectBranch,
306	superProjectVersion, subProject1Branch, subProject1Version,
307	subProject2Branch, subProject2Version }, new CVSTag[0]);
308	knownTags = Arrays.asList(repositoryManager
309	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject1)));
310	assertTags(knownTags, new CVSTag[] { subProject1Branch,
311	subProject1Version }, new CVSTag[] { subProject2Branch,
312	subProject2Version });
313	knownTags = Arrays.asList(repositoryManager
314	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(subProject2)));
315	assertTags(knownTags, new CVSTag[] { superProjectBranch,
316	superProjectVersion, subProject2Branch, subProject2Version },
317	new CVSTag[] { subProject1Branch, subProject1Version });
318	}
319
320	public void testTagsForSubfolder() throws TeamException, CoreException {
321	IProject project = createProject("Project_1", (String) null);
322	String folderName = "testFolder";
323	addResources(project, new String[] { folderName + "/",
324	folderName + "/testFile.txt" }, true);
325	IFolder folder = project.getFolder(folderName);
326	CVSTag branch1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
327	CVSTag.BRANCH);
328	CVSTag version1 = new CVSTag("Root_" + branch1.getName(),
329	CVSTag.VERSION);
330	makeBranch(new IResource[] { project }, version1, branch1, true);
331	// verify if project's tags are known for subfolder
332	ICVSFolder cvsFolder = CVSWorkspaceRoot.getCVSFolderFor(folder);
333	List knownTags = Arrays.asList(repositoryManager
334	.getKnownTags(cvsFolder));
335	assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[0]);
336	// verify if removing tags from subfolder is correctly handled
337	repositoryManager.removeTags(cvsFolder, new CVSTag[] { branch1,
338	version1 });
339	knownTags = Arrays.asList(repositoryManager.getKnownTags(cvsFolder));
340	assertTags(knownTags, new CVSTag[0], new CVSTag[] { branch1, version1 });
341	// verify if after refreshing tags are back for both project and its
342	// subfolder
343	refreshTags(cvsFolder);
344	knownTags = Arrays.asList(repositoryManager.getKnownTags(cvsFolder));
345	assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[0]);
346	knownTags = Arrays.asList(repositoryManager
347	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
348	assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[0]);
349	}
350
351	public void testRefreshProjectUsingAutoRefreshFile() throws CoreException {
352	IProject project = createProject("Project_1", (String) null);
353	String autoRefreshFileName = "sampleAuthoRefresh.txt";
354	String notAutoRefreshFileName = "notAutoRefresh.txt";
355	addResources(project, new String[] { autoRefreshFileName,
356	notAutoRefreshFileName }, true);
357	IFile autoRefreshFile = project.getFile(autoRefreshFileName);
358	IFile notAutoRefreshFile = project.getFile(notAutoRefreshFileName);
359	repositoryManager.setAutoRefreshFiles(
360	CVSWorkspaceRoot.getCVSFolderFor(project),
361	new String[] { CVSWorkspaceRoot.getCVSResourceFor(
362	autoRefreshFile).getRepositoryRelativePath() });
363	CVSTag branch1 = new CVSTag("Branch_1" + System.currentTimeMillis(),
364	CVSTag.BRANCH);
365	CVSTag version1 = new CVSTag("Root_" + branch1.getName(),
366	CVSTag.VERSION);
367	// branch the auto refresh file
368	makeBranch(new IResource[] { autoRefreshFile }, version1, branch1, true);
369	CVSTag branch2 = new CVSTag("Branch_2" + System.currentTimeMillis(),
370	CVSTag.BRANCH);
371	CVSTag version2 = new CVSTag("Root_" + branch2.getName(),
372	CVSTag.VERSION);
373	// branch not auto refresh file
374	makeBranch(new IResource[] { notAutoRefreshFile }, version2, branch2,
375	true);
376
377	clearRepositoryRootCache();
378	refreshTags(project);
379
380	// cache should contain branches from auto refresh file, but no branches
381	// from other files
382	List knownTags = Arrays.asList(repositoryManager
383	.getKnownTags(CVSWorkspaceRoot.getCVSFolderFor(project)));
384	assertTags(knownTags, new CVSTag[] { branch1, version1 }, new CVSTag[] {
385	branch2, version2 });
386	}
387
388	public void testProjectWithNoTags() throws CoreException {
389	IProject project = createProject("Project_1", (String) null);
390	CVSTag knownTags[] = repositoryManager.getKnownTags(CVSWorkspaceRoot
391	.getCVSFolderFor(project));
392	assertEquals(0, knownTags.length);
393	knownTags = refreshTags(project);
394	assertEquals(0, knownTags.length);
395	}
396
397	}

Added Link Here

(-)a/tests/org.eclipse.team.tests.cvs.core/src/org/eclipse/team/tests/ccvs/ui/RepositoriesViewTests.java (+254 lines)
1	/*******************************************************************************
2	* Copyright (c) 2011, 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.ui;
12
13	import junit.framework.Test;
14	import junit.framework.TestSuite;
15
16	import org.eclipse.core.resources.IProject;
17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.team.core.TeamException;
20	import org.eclipse.team.internal.ccvs.core.CVSTag;
21	import org.eclipse.team.internal.ccvs.core.resources.RemoteFolder;
22	import org.eclipse.team.internal.ccvs.core.resources.RemoteResource;
23	import org.eclipse.team.internal.ccvs.ui.model.AllRootsElement;
24	import org.eclipse.team.internal.ccvs.ui.model.BranchCategory;
25	import org.eclipse.team.internal.ccvs.ui.model.CVSTagElement;
26	import org.eclipse.team.internal.ccvs.ui.model.RemoteContentProvider;
27	import org.eclipse.team.internal.ccvs.ui.model.RemoteModule;
28	import org.eclipse.team.internal.ccvs.ui.model.VersionCategory;
29	import org.eclipse.team.internal.ccvs.ui.repo.RepositoryRoot;
30	import org.eclipse.team.tests.ccvs.core.CVSTestSetup;
31	import org.eclipse.team.tests.ccvs.core.EclipseTest;
32
33	public class RepositoriesViewTests extends EclipseTest {
34
35	public RepositoriesViewTests(String testName) {
36	super(testName);
37	}
38
39	protected void setUp() throws Exception {
40	super.setUp();
41	// clear repository root cache
42	RepositoryRoot repositoryRoot = getRepositoryRoot();
43	String remotePaths[] = repositoryRoot.getKnownRemotePaths();
44	for (int i = 0; i < remotePaths.length; i++) {
45	repositoryRoot.removeTags(remotePaths[i],
46	repositoryRoot.getAllKnownTags(remotePaths[i]));
47	}
48	}
49
50	private RepositoryRoot getRepositoryRoot() {
51	RemoteContentProvider rcp = new RemoteContentProvider();
52	AllRootsElement are = new AllRootsElement();
53	Object[] repositoryRoots = rcp.getElements(are);
54	for (int i = 0; i < repositoryRoots.length; i++) {
55	RepositoryRoot repositoryRoot = (RepositoryRoot) repositoryRoots[i];
56	if (getRepository().equals(repositoryRoot.getRoot())) {
57	return repositoryRoot;
58	}
59	}
60	fail(getRepository() + " not found");
61	return null;
62	}
63
64	public static Test suite() {
65	String testName = System.getProperty("eclipse.cvs.testName");
66	if (testName == null) {
67	TestSuite suite = new TestSuite(RepositoriesViewTests.class);
68	return new CVSTestSetup(suite);
69	} else {
70	return new CVSTestSetup(new RepositoriesViewTests(testName));
71	}
72	}
73
74	public void testBranchSubmoduleChildren() throws TeamException,
75	CoreException {
76
77	String time = Long.toString(System.currentTimeMillis());
78	String moduleName = "TestBranchSubmoduleChildrenTestModule" + time;
79	String branchName = "TestBranchSubmoduleChildrenBranch" + time;
80	String versionName = "Root_" + branchName;
81
82	// create project
83	IProject project = getUniqueTestProject("TestBranchSubmoduleChildrenProject");
84	// share project under module
85	shareProject(getRepository(), project,
86	moduleName + "/" + project.getName(), DEFAULT_MONITOR);
87	assertValidCheckout(project);
88
89	// add some files
90	addResources(project, new String[] { "file1.txt" }, true);
91
92	// make branch
93	CVSTag version = new CVSTag(versionName, CVSTag.VERSION);
94	CVSTag branch = new CVSTag(branchName, CVSTag.BRANCH);
95
96	makeBranch(new IResource[] { project }, version, branch, true);
97
98	// check if module is the only branch child
99	RemoteContentProvider rcp = new RemoteContentProvider();
100	Object[] categories = rcp.getChildren(getRepositoryRoot());
101	assertEquals(4, categories.length);
102	assertTrue(categories[1] instanceof BranchCategory);
103	Object[] branches = rcp.getChildren(categories[1]);
104	assertEquals(1, branches.length);
105	assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
106	.getName());
107	Object[] modules = rcp.getChildren(branches[0]);
108	assertEquals(1, modules.length);
109	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
110
111	// check if after refresh module is still the only branch child
112	branches = rcp.getChildren(categories[1]);
113	assertEquals(1, branches.length);
114	assertEquals(branchName, ((CVSTagElement) (branches[0])).getTag()
115	.getName());
116	modules = rcp.getChildren(branches[0]);
117	assertEquals(1, modules.length);
118	assertEquals(moduleName, ((RemoteResource) modules[0]).getName());
119	}
120
121	public void testTagSubmoduleChildren() throws TeamException, CoreException {
122
123	String time = Long.toString(System.currentTimeMillis());
124	String moduleName = "TestTagSubmoduleChildrenTestModule" + time;
125	String versionName = "TestTagSubmoduleChildrenBranch" + time;
126
127	// create project
128	IProject project = getUniqueTestProject("TestTagSubmoduleChildrenProject");
129	// share project under module
130	shareProject(getRepository(), project,
131	moduleName + "/" + project.getName(), DEFAULT_MONITOR);
132	assertValidCheckout(project);
133
134	// make some changes
135	addResources(project, new String[] { "file1.txt" }, true);
136
137	// tag project
138	CVSTag tag = new CVSTag(versionName, CVSTag.VERSION);
139
140	tagProject(project, tag, true);
141
142
143	RemoteContentProvider rcp = new RemoteContentProvider();
144	Object[] categories = rcp.getChildren(getRepositoryRoot());
145	assertEquals(4, categories.length);
146
147	// check if version exists for module
148	assertTrue(categories[2] instanceof VersionCategory);
149	Object[] modules = rcp.getChildren(categories[2]);
150	for (int i = 0; i < modules.length; i++) {
151	if (modules[i] instanceof RemoteModule
152	&& ((RemoteModule) (modules[i])).getCVSResource().getName()
153	.equals(moduleName)) {
154	Object folders[] = rcp.getChildren(modules[i]);
155	assertEquals(1, folders.length);
156	assertEquals(versionName, ((RemoteFolder) folders[0]).getTag()
157	.getName());
158	return;
159	}
160	}
161	fail(moduleName + " not found");
162	}
163
164	public void testTagsOnDifferentLevels() throws CoreException {
165	String time = Long.toString(System.currentTimeMillis());
166	String firstModule = "Module_1" + time;
167	String secondModule = "Module_2" + time;
168	String secondModulePath = firstModule + "/" + secondModule;
169	// Create repository data
170	// Module_1/Project_1
171	IProject project1 = getUniqueTestProject("Project_1");
172	shareProject(getRepository(), project1,
173	firstModule + "/" + project1.getName(), DEFAULT_MONITOR);
174	// Module_1/Module_2/Project_2
175	IProject project2 = getUniqueTestProject("Project_2");
176	shareProject(getRepository(), project2, secondModulePath + "/"
177	+ project2.getName(), DEFAULT_MONITOR);
178	// Module_1/Module_2/Project_3
179	IProject project3 = getUniqueTestProject("Project_3");
180	shareProject(getRepository(), project3, secondModulePath + "/"
181	+ project3.getName(), DEFAULT_MONITOR);
182	// Module_1/Project_4
183	IProject project4 = getUniqueTestProject("Project_4");
184	shareProject(getRepository(), project4,
185	firstModule + "/" + project4.getName(), DEFAULT_MONITOR);
186
187	// Create branches
188	String branch1 = "Branch_1" + time;
189	String version1 = "Root_" + branch1;
190	String branch2 = "Branch_2" + time;
191	String version2 = "Root_" + branch2;
192
193	// Tag projects:
194	// Module_1/Project_1 -> [Branch_1][Branch_2]
195	// Module_1/Module_2/Project_2 -> [Branch_1][Branch_2]
196	// Module_1/Module_2/Project_3 -> [Branch_2]
197	// Module_1/Project_4 -> [Branch_4]
198	makeBranch(new IResource[] { project1, project2 }, new CVSTag(version1,
199	CVSTag.VERSION), new CVSTag(branch1, CVSTag.BRANCH), true);
200	makeBranch(new IResource[] { project1, project2, project2, project4 },
201	new CVSTag(version2, CVSTag.VERSION), new CVSTag(branch2,
202	CVSTag.BRANCH), true);
203
204	// verify if tree structure is built from cache
205	RemoteContentProvider rcp = new RemoteContentProvider();
206	Object[] categories = rcp.getChildren(getRepositoryRoot());
207	assertEquals(4, categories.length);
208	assertTrue(categories[1] instanceof BranchCategory);
209	Object[] branches = rcp.getChildren(categories[1]);
210	assertEquals(2, branches.length); // should be [Branch_1] and [Branch_2]
211	CVSTagElement branch1Element;
212	CVSTagElement branch2Element;
213	if (((CVSTagElement) branches[0]).getTag().getName().equals(branch1)) {
214	branch1Element = (CVSTagElement) branches[0];
215	branch2Element = (CVSTagElement) branches[1];
216	} else {
217	branch1Element = (CVSTagElement) branches[1];
218	branch2Element = (CVSTagElement) branches[0];
219	}
220	Object[] modules = rcp.getChildren(branch1Element);
221	assertEquals(1, modules.length); // should be [Branch_1]/Module_1
222	assertEquals(firstModule, ((RemoteResource) modules[0]).getName());
223	modules = rcp.getChildren(modules[0]);
224	// should contain:
225	// [Branch_1]/Module_1/Project_1
226	// [Branch_1]/Module_1/Module_2
227	assertEquals(2, modules.length);
228	for (int i = 0; i < modules.length; i++) {
229	if (((RemoteResource) (modules[i])).getName().equals(
230	project1.getName())) {
231	// Project_1 should have contents retrieved from CVS
232	assertTrue(rcp.hasChildren(modules[i]));
233	} else if (((RemoteResource) (modules[i])).getName().equals(
234	secondModule)) {
235	// should be only [Branch_1]/Module_1/Module_2/Project_2.
236	// [Branch_1]/Module_1/Module_2/Project_3 should NOT be on the
237	// list, it is not branched with Branch_1
238	Object[] module2Children = rcp.getChildren(modules[i]);
239	assertEquals(1, module2Children.length);
240	assertEquals(project2.getName(),
241	((RemoteResource) module2Children[0]).getName());
242	}
243	}
244	modules = rcp.getChildren(branch2Element);
245	assertEquals(1, modules.length); // should be [Branch_2]/Module_1
246	assertEquals(firstModule, ((RemoteResource) modules[0]).getName());
247	// should contain:
248	// [Branch_2]/Module_1/Project_1
249	// [Branch_2]/Module_1/Module_2
250	// [Branch_2]/Module_1/Project_4
251	modules = rcp.getChildren(modules[0]);
252	assertEquals(3, modules.length);
253	}
254	}