| /******************************************************************************* |
| * Copyright (c) 2004, 2017 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.core.tests.resources.perf; |
| |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.eclipse.core.internal.localstore.IHistoryStore; |
| import org.eclipse.core.internal.resources.Workspace; |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.tests.harness.PerformanceTestRunner; |
| import org.eclipse.core.tests.internal.localstore.HistoryStoreTest; |
| import org.eclipse.core.tests.resources.ResourceTest; |
| |
| /** |
| * Contains a set of use case-oriented performance tests for the local history. |
| * |
| * @since 3.1 |
| */ |
| public class LocalHistoryPerformanceTest extends ResourceTest { |
| |
| private IWorkspaceDescription original; |
| |
| public static Test suite() { |
| // TestSuite suite = new TestSuite(LocalHistoryPerformanceTest.class.getName()); |
| // suite.addTest(new LocalHistoryPerformanceTest("testHistoryCleanUp100x4")); |
| // suite.addTest(new LocalHistoryPerformanceTest("testHistoryCleanUp4x100")); |
| // return suite; |
| return new TestSuite(LocalHistoryPerformanceTest.class); |
| } |
| |
| public LocalHistoryPerformanceTest(String name) { |
| super(name); |
| } |
| |
| void cleanHistory() { |
| ((Workspace) getWorkspace()).getFileSystemManager().getHistoryStore().clean(getMonitor()); |
| } |
| |
| /** |
| * Creates a tree of resources containing history. |
| */ |
| void createTree(IFolder base, final int filesPerFolder, final int statesPerFile) { |
| final IFolder[] folders = new IFolder[5]; |
| folders[0] = base.getFolder("folder1"); |
| folders[1] = base.getFolder("folder2"); |
| folders[2] = folders[0].getFolder("folder3"); |
| folders[3] = folders[2].getFolder("folder4"); |
| folders[4] = folders[3].getFolder("folder5"); |
| final IWorkspace workspace = getWorkspace(); |
| try { |
| workspace.run((IWorkspaceRunnable) monitor -> { |
| ensureExistsInWorkspace(folders, true); |
| for (IFolder folder : folders) { |
| for (int j = 0; j < filesPerFolder; j++) { |
| IFile file = folder.getFile("file" + j); |
| ensureExistsInWorkspace(file, getRandomContents()); |
| try { |
| for (int k = 0; k < statesPerFile; k++) { |
| file.setContents(getRandomContents(), IResource.KEEP_HISTORY, getMonitor()); |
| } |
| } catch (CoreException ce) { |
| fail("0.5", ce); |
| } |
| } |
| } |
| }, workspace.getRuleFactory().modifyRule(workspace.getRoot()), IWorkspace.AVOID_UPDATE, getMonitor()); |
| } catch (CoreException e) { |
| fail("#createTree at : " + base.getFullPath(), e); |
| } |
| } |
| |
| IWorkspaceDescription setMaxFileStates(String failureMessage, int maxFileStates) { |
| IWorkspaceDescription currentDescription = getWorkspace().getDescription(); |
| IWorkspaceDescription testDescription = getWorkspace().getDescription(); |
| testDescription.setMaxFileStates(maxFileStates); |
| try { |
| getWorkspace().setDescription(testDescription); |
| } catch (CoreException e) { |
| fail(failureMessage, e); |
| } |
| return currentDescription; |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| original = getWorkspace().getDescription(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| getWorkspace().setDescription(original); |
| super.tearDown(); |
| HistoryStoreTest.wipeHistoryStore(getMonitor()); |
| } |
| |
| public void testAddState() { |
| setMaxFileStates("0.01", 100); |
| final IFile file = getWorkspace().getRoot().getProject("proj1").getFile("file.txt"); |
| new PerformanceTestRunner() { |
| |
| @Override |
| protected void setUp() { |
| ensureExistsInWorkspace(file, getRandomContents()); |
| } |
| |
| @Override |
| protected void tearDown() { |
| try { |
| file.clearHistory(getMonitor()); |
| file.delete(IResource.FORCE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| } |
| |
| @Override |
| protected void test() { |
| try { |
| file.setContents(getRandomContents(), IResource.KEEP_HISTORY, getMonitor()); |
| } catch (CoreException e) { |
| fail("", e); |
| } |
| } |
| }.run(LocalHistoryPerformanceTest.this, 10, 30); |
| } |
| |
| public void testBug28603() { |
| final IProject project = getWorkspace().getRoot().getProject("myproject"); |
| final IFolder folder1 = project.getFolder("myfolder1"); |
| final IFolder folder2 = project.getFolder("myfolder2"); |
| final IFile file1 = folder1.getFile("myfile.txt"); |
| final IFile file2 = folder2.getFile(file1.getName()); |
| |
| new PerformanceTestRunner() { |
| |
| @Override |
| protected void setUp() { |
| ensureExistsInWorkspace(new IResource[] {project, folder1, folder2}, true); |
| try { |
| file1.create(getRandomContents(), IResource.FORCE, getMonitor()); |
| file1.setContents(getRandomContents(), IResource.FORCE | IResource.KEEP_HISTORY, getMonitor()); |
| file1.setContents(getRandomContents(), IResource.FORCE | IResource.KEEP_HISTORY, getMonitor()); |
| file1.setContents(getRandomContents(), IResource.FORCE | IResource.KEEP_HISTORY, getMonitor()); |
| } catch (CoreException e) { |
| fail("0.0", e); |
| } |
| } |
| |
| @Override |
| protected void tearDown() { |
| try { |
| ensureDoesNotExistInWorkspace(getWorkspace().getRoot()); |
| IHistoryStore store = ((Workspace) getWorkspace()).getFileSystemManager().getHistoryStore(); |
| // Remove all the entries from the history store index. Note that |
| // this does not cause the history store states to be removed. |
| store.remove(Path.ROOT, getMonitor()); |
| // Now make sure all the states are really removed. |
| store.removeGarbage(); |
| } catch (Exception e) { |
| fail("2.0", e); |
| } |
| } |
| |
| @Override |
| protected void test() { |
| try { |
| file1.move(file2.getFullPath(), true, true, getMonitor()); |
| file2.move(file1.getFullPath(), true, true, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| } |
| }.run(this, 10, 5); |
| } |
| |
| private void testClearHistory(final int filesPerFolder, final int statesPerFile) { |
| IProject project = getWorkspace().getRoot().getProject("proj1"); |
| final IFolder base = project.getFolder("base"); |
| ensureDoesNotExistInWorkspace(base); |
| new PerformanceTestRunner() { |
| private IWorkspaceDescription original; |
| |
| @Override |
| protected void setUp() { |
| original = setMaxFileStates("0.1", 1); |
| // make sure we start with no garbage |
| cleanHistory(); |
| // create our own garbage |
| createTree(base, filesPerFolder, statesPerFile); |
| ensureDoesNotExistInWorkspace(base); |
| } |
| |
| @Override |
| protected void tearDown() throws CoreException { |
| if (original != null) { |
| getWorkspace().setDescription(original); |
| } |
| } |
| |
| @Override |
| protected void test() { |
| try { |
| base.clearHistory(getMonitor()); |
| } catch (CoreException e) { |
| fail("", e); |
| } |
| } |
| }.run(this, 4, 3); |
| } |
| |
| public void testClearHistory100x4() { |
| testClearHistory(100, 4); |
| } |
| |
| public void testClearHistory20x20() { |
| testClearHistory(20, 20); |
| } |
| |
| public void testClearHistory4x100() { |
| testClearHistory(4, 100); |
| } |
| |
| private void testCopyHistory(int filesPerFolder, int statesPerFile) { |
| IProject project = getWorkspace().getRoot().getProject("proj1"); |
| IFolder base = project.getFolder("base"); |
| createTree(base, filesPerFolder, statesPerFile); |
| // need a final reference so the inner class can see it |
| final IProject[] tmpProject = new IProject[] {project}; |
| new PerformanceTestRunner() { |
| @Override |
| protected void test() { |
| try { |
| String newProjectName = getUniqueString(); |
| IProject newProject = getWorkspace().getRoot().getProject(newProjectName); |
| tmpProject[0].copy(newProject.getFullPath(), true, getMonitor()); |
| tmpProject[0] = newProject; |
| } catch (CoreException e) { |
| fail("", e); |
| } |
| } |
| }.run(this, 10, 1); |
| } |
| |
| public void testCopyHistory100x4() { |
| testCopyHistory(100, 4); |
| } |
| |
| public void testCopyHistory20x20() { |
| testCopyHistory(20, 20); |
| } |
| |
| public void testCopyHistory4x100() { |
| testCopyHistory(4, 100); |
| } |
| |
| private void testGetDeletedMembers(int filesPerFolder, int statesPerFile) { |
| IProject project = getWorkspace().getRoot().getProject("proj1"); |
| IFolder base = project.getFolder("base"); |
| createTree(base, filesPerFolder, statesPerFile); |
| ensureDoesNotExistInWorkspace(base); |
| // need a final reference so the inner class can see it |
| final IProject tmpProject = project; |
| new PerformanceTestRunner() { |
| @Override |
| protected void test() { |
| try { |
| tmpProject.findDeletedMembersWithHistory(IResource.DEPTH_INFINITE, getMonitor()); |
| } catch (CoreException e) { |
| fail("", e); |
| } |
| } |
| }.run(this, 2, 5); |
| } |
| |
| public void testGetDeletedMembers100x4() { |
| testGetDeletedMembers(100, 4); |
| } |
| |
| public void testGetDeletedMembers20x20() { |
| testGetDeletedMembers(20, 20); |
| } |
| |
| public void testGetDeletedMembers4x100() { |
| testGetDeletedMembers(4, 100); |
| } |
| |
| public void testGetHistory() { |
| IProject project = getWorkspace().getRoot().getProject("proj1"); |
| final IFile file = project.getFile("file.txt"); |
| ensureExistsInWorkspace(file, getRandomContents()); |
| try { |
| for (int i = 0; i < 100; i++) { |
| file.setContents(getRandomContents(), IResource.KEEP_HISTORY, getMonitor()); |
| } |
| } catch (CoreException ce) { |
| fail("0.5", ce); |
| } |
| new PerformanceTestRunner() { |
| @Override |
| protected void test() { |
| try { |
| file.getHistory(getMonitor()); |
| } catch (CoreException e) { |
| fail("", e); |
| } |
| } |
| }.run(this, 1, 150); |
| } |
| |
| private void testHistoryCleanUp(final int filesPerFolder, final int statesPerFile) { |
| IProject project = getWorkspace().getRoot().getProject("proj1"); |
| final IFolder base = project.getFolder("base"); |
| ensureDoesNotExistInWorkspace(base); |
| new PerformanceTestRunner() { |
| private IWorkspaceDescription original; |
| |
| @Override |
| protected void setUp() { |
| original = setMaxFileStates("0.1", 1); |
| // make sure we start with no garbage |
| cleanHistory(); |
| // create our own garbage |
| createTree(base, filesPerFolder, statesPerFile); |
| ensureDoesNotExistInWorkspace(base); |
| } |
| |
| @Override |
| protected void tearDown() throws CoreException { |
| if (original != null) { |
| getWorkspace().setDescription(original); |
| } |
| } |
| |
| @Override |
| protected void test() { |
| cleanHistory(); |
| } |
| |
| }.run(this, 5, 1); |
| } |
| |
| public void testHistoryCleanUp100x4() { |
| testHistoryCleanUp(100, 4); |
| } |
| |
| public void testHistoryCleanUp20x20() { |
| testHistoryCleanUp(20, 20); |
| } |
| } |