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