tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/internal/watson/TestUtil.java - platform/eclipse.platform.resources - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2015 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
  *     Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
  *******************************************************************************/
 package org.eclipse.core.tests.internal.watson;

 import java.util.Random;
 import java.util.Vector;
 import org.eclipse.core.internal.watson.*;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;

 /**
  * Framework for running tests on element tree components.
  * Supplies convenience methods and some representative element trees.
  */
 abstract class TestUtil extends WatsonTest implements IPathConstants {
 	public TestUtil(String name) {
 		super(name);
 	}

 	static final IElementComparator fComparator = TestElementComparator.getComparator();

 	/**
 	 * Asserts that the given comparison value has the added
 	 * bit set, and the changed/removed bits blank
 	 */
 	static void assertAdded(int compare) {
 		assertTrue(compare == TestElementComparator.ADDED);
 	}

 	/**
 	 * Asserts that the given comparison value has the changed
 	 * bit set, and the added/removed bits blank
 	 */
 	static void assertChanged(int compare) {
 		assertTrue(compare == TestElementComparator.CHANGED);
 	}

 	/**
 	 * Asserts that two trees are equal. If they are not
 	 * an AssertionFailedError is thrown.
 	 * @param message the detail message for this assertion
 	 * @param expected the expected value of a tree
 	 * @param actual the actual value of a tree
 	 */
 	static protected void assertEqualTrees(String message, ElementTree expected, ElementTree actual) {
 		assertEqualTrees(message, expected, actual, Path.ROOT, ElementTreeWriter.D_INFINITE);
 	}

 	/**
 	 * Asserts that two trees are equal. If they are not
 	 * an AssertionFailedError is thrown.
 	 * @param message the detail message for this assertion
 	 * @param expected the expected value of a tree
 	 * @param actual the actual value of a tree
 	 * @param depth The depth to compare to.
 	 */
 	static protected void assertEqualTrees(String message, ElementTree expected, ElementTree actual, int depth) {
 		assertEqualTrees(message, expected, actual, Path.ROOT, depth);
 	}

 	/**
 	 * Asserts that two trees are equal from the given path downwards. If they are not
 	 * an AssertionFailedError is thrown.
 	 * @param message the detail message for this assertion
 	 * @param expected the expected value of a tree
 	 * @param actual the actual value of a tree
 	 */
 	static protected void assertEqualTrees(String message, ElementTree expected, ElementTree actual, IPath path) {
 		assertEqualTrees(message, expected, actual, path, ElementTreeWriter.D_INFINITE);
 	}

 	/**
 	 * Asserts that two trees are equal. If they are not
 	 * an AssertionFailedError is thrown.
 	 * @param message the detail message for this assertion
 	 * @param expected the expected value of a tree
 	 * @param actual the actual value of a tree
 	 * @param depth The depth to compare to.
 	 */
 	static protected void assertEqualTrees(String msg, ElementTree expected, ElementTree actual, IPath path, int depth) {
 		/* check node at current path */
 		assertTrue(msg, expected.includes(path));
 		assertTrue(msg, actual.includes(path));
 		assertEquals(msg, expected.getElementData(path), actual.getElementData(path));

 		if (depth != 0) {
 			/* get the children */
 			IPath[] expectedChildren = expected.getChildren(path);
 			IPath[] actualChildren = actual.getChildren(path);
 			assertTrue("Number of children", expectedChildren.length == actualChildren.length);

 			int newDepth = depth;
 			if (depth != ElementTreeWriter.D_INFINITE) {
 				--newDepth;
 			}
 			for (int i = 0; i < expectedChildren.length; i++) {
 				assertEquals("children IDs", expectedChildren[i], actualChildren[i]);
 				assertEqualTrees("Recursive call", expected, actual, expectedChildren[i], newDepth);
 			}
 		}
 	}

 	/**
 	 * Asserts that the given tree contains all of the given paths
 	 */
 	static protected void assertHasPaths(ElementTree tree, IPath[] paths) {
 		for (int i = 0; i < paths.length; i++) {
 			assertTrue("assertHasPaths" + i, tree.includes(paths[i]));
 		}
 	}

 	/**
 	 * Asserts that the given comparison value has the changed
 	 * bit set, and the added/removed bits blank
 	 */
 	static void assertNoChange(int compare) {
 		assertTrue(compare == 0);
 	}

 	/**
 	 * Asserts that the given tree doesn not contain all of the given paths
 	 */
 	static protected void assertNoPaths(ElementTree tree, IPath[] paths) {
 		for (int i = 0; i < paths.length; i++) {
 			assertTrue("assertNoPaths: " + paths[i], !tree.includes(paths[i]));
 		}
 	}

 	/**
 	 * Asserts that the given comparison value has the removed
 	 * bit set, and the changed/added bits blank
 	 */
 	static void assertRemoved(int compare) {
 		assertTrue(compare == TestElementComparator.REMOVED);
 	}

 	/**
 	 * Asserts that the Test ElementTree has its original structure
 	 */
 	static protected void assertTreeStructure(ElementTree tree) {
 		assertHasPaths(tree, getTreePaths());

 		IPath[] children = tree.getChildren(Path.ROOT);
 		assertTrue(children.length == 1);

 		/* solution children */
 		children = tree.getChildren(children[0]);
 		assertTrue(children.length == 2);
 		assertTrue(tree.getChildren(project1).length == 0);

 		/* project2 children */
 		children = tree.getChildren(children[1]);
 		assertTrue(children.length == 3);
 		assertTrue(tree.getChildren(file1).length == 0);
 		assertTrue(tree.getChildren(folder2).length == 0);

 		/* folder1 children */
 		children = tree.getChildren(children[1]);
 		assertTrue(children.length == 3);
 		assertTrue(tree.getChildren(file2).length == 0);
 		assertTrue(tree.getChildren(folder4).length == 0);

 		/* folder3 children */
 		children = tree.getChildren(children[1]);
 		assertTrue(children.length == 1);
 		assertTrue(tree.getChildren(file3).length == 0);
 	}

 	static ElementTree createTestElementTree() {
 		/**
 		 * This is a sample element tree on which tests are performed.
 		 * The Paths in this tree are found in IPathConstants.  The tree's
 		 * basic structure is as follows:
 		 *	solution
 		 *		project1
 		 *		project2
 		 *			file1
 		 *			folder1
 		 *				file2
 		 *				folder3
 		 *					file3
 		 *				folder4
 		 *			folder2
 		 */

 		ElementTree tree = new ElementTree();
 		tree.createElement(solution, new String("solution"));
 		tree.createElement(project1, new String("project1"));
 		tree.createElement(project2, new String("project2"));
 		tree.createElement(file1, new String("file1"));
 		tree.createElement(folder1, new String("folder1"));
 		tree.createElement(folder2, new String("folder2"));
 		tree.createElement(file2, new String("file2"));
 		tree.createElement(folder3, new String("folder3"));
 		tree.createElement(folder4, new String("folder4"));
 		tree.createElement(file3, new String("file3"));

 		return tree;
 	}

 	/**
 	 * Does several routine operations on the subtree rooted at
 	 * the given path.  Opens a new delta after every operation.
 	 * Returns an array of all the intermediary ElementTrees.
 	 */
 	static protected ElementTree[] doManyRoutineOperations(ElementTree tree, IPath path) {
 		Vector<ElementTree> trees = new Vector<>();
 		trees.addElement(tree);

 		int repeat = 1;

 		/* create file elements */
 		tree = tree.newEmptyDelta();
 		IPath[] files = getFilePaths(path);
 		for (IPath file : files) {
 			Object data = file.toString();
 			tree.createElement(file, data);

 			tree.immutable();
 			trees.addElement(tree);
 			tree = tree.newEmptyDelta();
 		}

 		/* modify the data of all file elements a few times */
 		for (int i = 0; i < repeat; i++) {
 			Object data = "data" + i;
 			for (IPath file : files) {
 				tree.setElementData(file, data);
 				tree.immutable();
 				trees.addElement(tree);
 				tree = tree.newEmptyDelta();
 			}
 		}

 		/* delete all file elements */
 		for (IPath file : files) {
 			tree.deleteElement(file);
 			tree.immutable();
 			trees.addElement(tree);
 			tree = tree.newEmptyDelta();
 		}

 		ElementTree[] results = new ElementTree[trees.size()];
 		trees.copyInto(results);
 		return results;
 	}

 	/**
 	 * Does several routine operations on the subtree rooted at
 	 * the given path.  Returns an array of all the intermediary elementtrees.
 	 */
 	static protected ElementTree[] doRoutineOperations(ElementTree tree, IPath path) {
 		Vector<ElementTree> trees = new Vector<>();
 		trees.addElement(tree);

 		int repeat = 1;

 		/* create file elements */
 		tree = tree.newEmptyDelta();
 		IPath[] files = getFilePaths(path);
 		for (IPath file : files) {
 			Object data = file.toString();

 			tree.createElement(file, data);
 		}

 		tree.immutable();
 		trees.addElement(tree);
 		tree = tree.newEmptyDelta();

 		/* modify the data of all file elements a few times */
 		for (int i = 0; i < repeat; i++) {
 			Object data = "data" + i;
 			for (IPath file : files) {
 				tree.setElementData(file, data);
 			}
 		}

 		tree.immutable();
 		trees.addElement(tree);
 		tree = tree.newEmptyDelta();

 		/* delete all file elements */
 		for (IPath file : files) {
 			tree.deleteElement(file);
 		}

 		tree.immutable();
 		trees.addElement(tree);

 		ElementTree[] results = new ElementTree[trees.size()];
 		trees.copyInto(results);
 		return results;
 	}

 	/**
 	 * Returns an element tree comparator
 	 */
 	static IElementComparator getComparator() {
 		return fComparator;
 	}

 	/**
 	 * Returns an array of paths below the given path.
 	 */
 	static protected IPath[] getFilePaths(IPath project3) {
 		String[] names = getJavaLangUnits();
 		IPath[] paths = new IPath[names.length];
 		for (int i = 0; i < paths.length; i++) {
 			paths[i] = project3.append(names[i]);
 		}
 		return paths;
 	}

 	/**
 	 * Returns strings representing javalang classes
 	 */
 	static protected String[] getJavaLangUnits() {
 		return new String[] {"AbstractMethodError.java", "ArithmeticException.java", "ArrayIndexOutOfBoundsException.java", "ArrayStoreException.java", "Boolean.java", "Byte.java", "Character.java", "Class.java", "ClassCastException.java", "ClassCircularityError.java", "ClassFormatError.java", "ClassLoader.java", "ClassNotFoundException.java", "Cloneable.java", "CloneNotSupportedException.java", "Compiler.java", "Double.java", "Error.java",};
 	}

 	/**
 	 * Returns the paths for all the elements in the tree in top-down order
 	 */
 	static protected IPath[] getTreePaths() {
 		return new IPath[] {solution, project1, project2, folder1, folder2, folder3, folder4, file1, file2, file3};
 	}

 	/**
 	 * Randomly scrambles an array.
 	 */
 	static protected void scramble(Object[] first) {
 		Random random = new Random(System.currentTimeMillis());

 		final int len = first.length;
 		for (int i = 0; i < len * 100; i++) {
 			/* get any array offset */
 			int off1 = (int) (random.nextFloat() * len);
 			if (off1 == len) {
 				continue;
 			}

 			/* get another array offset */
 			int off2 = (int) (random.nextFloat() * len);
 			if (off2 == len) {
 				continue;
 			}

 			/* switch */
 			Object temp = first[off1];
 			first[off1] = first[off2];
 			first[off2] = temp;
 		}
 	}

 	/**
 	 * Randomly scrambles two arrays, ensuring that both
 	 * arrays undergo the same permutation.
 	 */
 	static protected void scramble(Object[] first, Object[] second) {
 		assertTrue(first.length == second.length);
 		Random random = new Random(System.currentTimeMillis());

 		final int len = first.length;
 		for (int i = 0; i < len * 100; i++) {
 			/* get any array offset */
 			int off1 = (int) (random.nextFloat() * len);
 			if (off1 == len) {
 				continue;
 			}

 			/* get another array offset */
 			int off2 = (int) (random.nextFloat() * len);
 			if (off2 == len) {
 				continue;
 			}

 			/* switch */
 			Object temp = first[off1];
 			first[off1] = first[off2];
 			first[off2] = temp;

 			temp = second[off1];
 			second[off1] = second[off2];
 			second[off2] = temp;
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2015 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
	* Alexander Kurtakov <akurtako@redhat.com> - Bug 459343
	*******************************************************************************/
	package org.eclipse.core.tests.internal.watson;

	import java.util.Random;
	import java.util.Vector;
	import org.eclipse.core.internal.watson.*;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;

	/**
	* Framework for running tests on element tree components.
	* Supplies convenience methods and some representative element trees.
	*/
	abstract class TestUtil extends WatsonTest implements IPathConstants {
	public TestUtil(String name) {
	super(name);
	}

	static final IElementComparator fComparator = TestElementComparator.getComparator();

	/**
	* Asserts that the given comparison value has the added
	* bit set, and the changed/removed bits blank
	*/
	static void assertAdded(int compare) {
	assertTrue(compare == TestElementComparator.ADDED);
	}

	/**
	* Asserts that the given comparison value has the changed
	* bit set, and the added/removed bits blank
	*/
	static void assertChanged(int compare) {
	assertTrue(compare == TestElementComparator.CHANGED);
	}

	/**
	* Asserts that two trees are equal. If they are not
	* an AssertionFailedError is thrown.
	* @param message the detail message for this assertion
	* @param expected the expected value of a tree
	* @param actual the actual value of a tree
	*/
	static protected void assertEqualTrees(String message, ElementTree expected, ElementTree actual) {
	assertEqualTrees(message, expected, actual, Path.ROOT, ElementTreeWriter.D_INFINITE);
	}

	/**
	* Asserts that two trees are equal. If they are not
	* an AssertionFailedError is thrown.
	* @param message the detail message for this assertion
	* @param expected the expected value of a tree
	* @param actual the actual value of a tree
	* @param depth The depth to compare to.
	*/
	static protected void assertEqualTrees(String message, ElementTree expected, ElementTree actual, int depth) {
	assertEqualTrees(message, expected, actual, Path.ROOT, depth);
	}

	/**
	* Asserts that two trees are equal from the given path downwards. If they are not
	* an AssertionFailedError is thrown.
	* @param message the detail message for this assertion
	* @param expected the expected value of a tree
	* @param actual the actual value of a tree
	*/
	static protected void assertEqualTrees(String message, ElementTree expected, ElementTree actual, IPath path) {
	assertEqualTrees(message, expected, actual, path, ElementTreeWriter.D_INFINITE);
	}

	/**
	* Asserts that two trees are equal. If they are not
	* an AssertionFailedError is thrown.
	* @param message the detail message for this assertion
	* @param expected the expected value of a tree
	* @param actual the actual value of a tree
	* @param depth The depth to compare to.
	*/
	static protected void assertEqualTrees(String msg, ElementTree expected, ElementTree actual, IPath path, int depth) {
	/* check node at current path */
	assertTrue(msg, expected.includes(path));
	assertTrue(msg, actual.includes(path));
	assertEquals(msg, expected.getElementData(path), actual.getElementData(path));

	if (depth != 0) {
	/* get the children */
	IPath[] expectedChildren = expected.getChildren(path);
	IPath[] actualChildren = actual.getChildren(path);
	assertTrue("Number of children", expectedChildren.length == actualChildren.length);

	int newDepth = depth;
	if (depth != ElementTreeWriter.D_INFINITE) {
	--newDepth;
	}
	for (int i = 0; i < expectedChildren.length; i++) {
	assertEquals("children IDs", expectedChildren[i], actualChildren[i]);
	assertEqualTrees("Recursive call", expected, actual, expectedChildren[i], newDepth);
	}
	}
	}

	/**
	* Asserts that the given tree contains all of the given paths
	*/
	static protected void assertHasPaths(ElementTree tree, IPath[] paths) {
	for (int i = 0; i < paths.length; i++) {
	assertTrue("assertHasPaths" + i, tree.includes(paths[i]));
	}
	}

	/**
	* Asserts that the given comparison value has the changed
	* bit set, and the added/removed bits blank
	*/
	static void assertNoChange(int compare) {
	assertTrue(compare == 0);
	}

	/**
	* Asserts that the given tree doesn not contain all of the given paths
	*/
	static protected void assertNoPaths(ElementTree tree, IPath[] paths) {
	for (int i = 0; i < paths.length; i++) {
	assertTrue("assertNoPaths: " + paths[i], !tree.includes(paths[i]));
	}
	}

	/**
	* Asserts that the given comparison value has the removed
	* bit set, and the changed/added bits blank
	*/
	static void assertRemoved(int compare) {
	assertTrue(compare == TestElementComparator.REMOVED);
	}

	/**
	* Asserts that the Test ElementTree has its original structure
	*/
	static protected void assertTreeStructure(ElementTree tree) {
	assertHasPaths(tree, getTreePaths());

	IPath[] children = tree.getChildren(Path.ROOT);
	assertTrue(children.length == 1);

	/* solution children */
	children = tree.getChildren(children[0]);
	assertTrue(children.length == 2);
	assertTrue(tree.getChildren(project1).length == 0);

	/* project2 children */
	children = tree.getChildren(children[1]);
	assertTrue(children.length == 3);
	assertTrue(tree.getChildren(file1).length == 0);
	assertTrue(tree.getChildren(folder2).length == 0);

	/* folder1 children */
	children = tree.getChildren(children[1]);
	assertTrue(children.length == 3);
	assertTrue(tree.getChildren(file2).length == 0);
	assertTrue(tree.getChildren(folder4).length == 0);

	/* folder3 children */
	children = tree.getChildren(children[1]);
	assertTrue(children.length == 1);
	assertTrue(tree.getChildren(file3).length == 0);
	}

	static ElementTree createTestElementTree() {
	/**
	* This is a sample element tree on which tests are performed.
	* The Paths in this tree are found in IPathConstants. The tree's
	* basic structure is as follows:
	* solution
	* project1
	* project2
	* file1
	* folder1
	* file2
	* folder3
	* file3
	* folder4
	* folder2
	*/

	ElementTree tree = new ElementTree();
	tree.createElement(solution, new String("solution"));
	tree.createElement(project1, new String("project1"));
	tree.createElement(project2, new String("project2"));
	tree.createElement(file1, new String("file1"));
	tree.createElement(folder1, new String("folder1"));
	tree.createElement(folder2, new String("folder2"));
	tree.createElement(file2, new String("file2"));
	tree.createElement(folder3, new String("folder3"));
	tree.createElement(folder4, new String("folder4"));
	tree.createElement(file3, new String("file3"));

	return tree;
	}

	/**
	* Does several routine operations on the subtree rooted at
	* the given path. Opens a new delta after every operation.
	* Returns an array of all the intermediary ElementTrees.
	*/
	static protected ElementTree[] doManyRoutineOperations(ElementTree tree, IPath path) {
	Vector<ElementTree> trees = new Vector<>();
	trees.addElement(tree);

	int repeat = 1;

	/* create file elements */
	tree = tree.newEmptyDelta();
	IPath[] files = getFilePaths(path);
	for (IPath file : files) {
	Object data = file.toString();
	tree.createElement(file, data);

	tree.immutable();
	trees.addElement(tree);
	tree = tree.newEmptyDelta();
	}

	/* modify the data of all file elements a few times */
	for (int i = 0; i < repeat; i++) {
	Object data = "data" + i;
	for (IPath file : files) {
	tree.setElementData(file, data);
	tree.immutable();
	trees.addElement(tree);
	tree = tree.newEmptyDelta();
	}
	}

	/* delete all file elements */
	for (IPath file : files) {
	tree.deleteElement(file);
	tree.immutable();
	trees.addElement(tree);
	tree = tree.newEmptyDelta();
	}

	ElementTree[] results = new ElementTree[trees.size()];
	trees.copyInto(results);
	return results;
	}

	/**
	* Does several routine operations on the subtree rooted at
	* the given path. Returns an array of all the intermediary elementtrees.
	*/
	static protected ElementTree[] doRoutineOperations(ElementTree tree, IPath path) {
	Vector<ElementTree> trees = new Vector<>();
	trees.addElement(tree);

	int repeat = 1;

	/* create file elements */
	tree = tree.newEmptyDelta();
	IPath[] files = getFilePaths(path);
	for (IPath file : files) {
	Object data = file.toString();

	tree.createElement(file, data);
	}

	tree.immutable();
	trees.addElement(tree);
	tree = tree.newEmptyDelta();

	/* modify the data of all file elements a few times */
	for (int i = 0; i < repeat; i++) {
	Object data = "data" + i;
	for (IPath file : files) {
	tree.setElementData(file, data);
	}
	}

	tree.immutable();
	trees.addElement(tree);
	tree = tree.newEmptyDelta();

	/* delete all file elements */
	for (IPath file : files) {
	tree.deleteElement(file);
	}

	tree.immutable();
	trees.addElement(tree);

	ElementTree[] results = new ElementTree[trees.size()];
	trees.copyInto(results);
	return results;
	}

	/**
	* Returns an element tree comparator
	*/
	static IElementComparator getComparator() {
	return fComparator;
	}

	/**
	* Returns an array of paths below the given path.
	*/
	static protected IPath[] getFilePaths(IPath project3) {
	String[] names = getJavaLangUnits();
	IPath[] paths = new IPath[names.length];
	for (int i = 0; i < paths.length; i++) {
	paths[i] = project3.append(names[i]);
	}
	return paths;
	}

	/**
	* Returns strings representing javalang classes
	*/
	static protected String[] getJavaLangUnits() {
	return new String[] {"AbstractMethodError.java", "ArithmeticException.java", "ArrayIndexOutOfBoundsException.java", "ArrayStoreException.java", "Boolean.java", "Byte.java", "Character.java", "Class.java", "ClassCastException.java", "ClassCircularityError.java", "ClassFormatError.java", "ClassLoader.java", "ClassNotFoundException.java", "Cloneable.java", "CloneNotSupportedException.java", "Compiler.java", "Double.java", "Error.java",};
	}

	/**
	* Returns the paths for all the elements in the tree in top-down order
	*/
	static protected IPath[] getTreePaths() {
	return new IPath[] {solution, project1, project2, folder1, folder2, folder3, folder4, file1, file2, file3};
	}

	/**
	* Randomly scrambles an array.
	*/
	static protected void scramble(Object[] first) {
	Random random = new Random(System.currentTimeMillis());

	final int len = first.length;
	for (int i = 0; i < len * 100; i++) {
	/* get any array offset */
	int off1 = (int) (random.nextFloat() * len);
	if (off1 == len) {
	continue;
	}

	/* get another array offset */
	int off2 = (int) (random.nextFloat() * len);
	if (off2 == len) {
	continue;
	}

	/* switch */
	Object temp = first[off1];
	first[off1] = first[off2];
	first[off2] = temp;
	}
	}

	/**
	* Randomly scrambles two arrays, ensuring that both
	* arrays undergo the same permutation.
	*/
	static protected void scramble(Object[] first, Object[] second) {
	assertTrue(first.length == second.length);
	Random random = new Random(System.currentTimeMillis());

	final int len = first.length;
	for (int i = 0; i < len * 100; i++) {
	/* get any array offset */
	int off1 = (int) (random.nextFloat() * len);
	if (off1 == len) {
	continue;
	}

	/* get another array offset */
	int off2 = (int) (random.nextFloat() * len);
	if (off2 == len) {
	continue;
	}

	/* switch */
	Object temp = first[off1];
	first[off1] = first[off2];
	first[off2] = temp;

	temp = second[off1];
	second[off1] = second[off2];
	second[off2] = temp;
	}
	}

	}