tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/perf/LocalHistoryPerformanceTest.java - platform/eclipse.platform.resources - Git at Google

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