| ///******************************************************************************* |
| // * Copyright (c) 2000, 2006 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.ui.tests.performance; |
| // |
| //import java.util.ArrayList; |
| //import java.util.HashSet; |
| //import java.util.List; |
| //import java.util.Locale; |
| //import java.util.Set; |
| // |
| //import org.eclipse.core.commands.Command; |
| //import org.eclipse.core.commands.CommandManager; |
| //import org.eclipse.core.commands.ParameterizedCommand; |
| //import org.eclipse.core.commands.common.NotDefinedException; |
| //import org.eclipse.core.commands.contexts.Context; |
| //import org.eclipse.core.commands.contexts.ContextManager; |
| //import org.eclipse.jface.bindings.Binding; |
| //import org.eclipse.jface.bindings.BindingManager; |
| //import org.eclipse.jface.bindings.Scheme; |
| //import org.eclipse.jface.bindings.keys.IKeyLookup; |
| //import org.eclipse.jface.bindings.keys.KeyBinding; |
| //import org.eclipse.jface.bindings.keys.KeyLookupFactory; |
| //import org.eclipse.jface.bindings.keys.KeySequence; |
| //import org.eclipse.jface.bindings.keys.KeyStroke; |
| //import org.eclipse.jface.bindings.keys.ParseException; |
| //import org.eclipse.swt.SWT; |
| // |
| ///** |
| // * <p> |
| // * Responsible for testing the commands, contexts and bindings architecture. |
| // * This test does not rely on the existence of the workbench; it operates purely |
| // * on JFace code and lower. See the method comments for descriptions of the |
| // * currently supported performance tests. |
| // * </p> |
| // * |
| // * @since 3.1 |
| // */ |
| //public final class CommandsPerformanceTest extends BasicPerformanceTest { |
| // |
| // /** |
| // * <p> |
| // * Constructs a branch of a context tree. This creates a branch of the given |
| // * depth -- remembering the identifiers along the way. This method operates |
| // * recursively. |
| // * </p> |
| // * <p> |
| // * TODO This should add a bit of breadth to the tree. |
| // * </p> |
| // * |
| // * @param contextManager |
| // * The context manager in which the contexts should be defined; |
| // * must not be <code>null</code>. |
| // * @param parent |
| // * The parent context identifier for the context to be created; |
| // * may be <code>null</code>. |
| // * @param successors |
| // * The number of successors to create. The depth of the branch to |
| // * be created. If this number is zero, then a context is created, |
| // * but no recursive call is made. |
| // * @param activeContextIds |
| // * The list of active context identifiers; must not be |
| // * <code>null</code>. |
| // */ |
| // private static final void createContext( |
| // final ContextManager contextManager, final String parent, |
| // final int successors, final List activeContextIds) { |
| // final int count = activeContextIds.size(); |
| // final String contextString = "context" + count; |
| // final Context context = contextManager.getContext(contextString); |
| // context.define(contextString, contextString, parent); |
| // activeContextIds.add(contextString); |
| // |
| // if (successors == 0) { |
| // return; |
| // } |
| // |
| // createContext(contextManager, contextString, successors - 1, |
| // activeContextIds); |
| // } |
| // |
| // /** |
| // * <p> |
| // * Constructs a branch of a scheme tree. This creates a branch of the given |
| // * depth -- remembering the schemes along the way. This method operates |
| // * recursively. |
| // * </p> |
| // * <p> |
| // * TODO This should add a bit of breadth to the tree. |
| // * </p> |
| // * |
| // * @param bindingManager |
| // * The binding manager in which the schemes should be defined; |
| // * must not be <code>null</code>. |
| // * @param parent |
| // * The parent scheme identifier for the scheme to be created; may |
| // * be <code>null</code>. |
| // * @param successors |
| // * The number of successors to create. The depth of the branch to |
| // * be created. If this number is zero, then a scheme is created, |
| // * but no recursive call is made. |
| // * @param schemes |
| // * The list of created schemes; must not be <code>null</code>. |
| // */ |
| // private static final void createScheme(final BindingManager bindingManager, |
| // final String parent, final int successors, final List schemes) { |
| // final int count = schemes.size(); |
| // final String schemeString = "scheme" + count; |
| // final Scheme scheme = bindingManager.getScheme(schemeString); |
| // scheme.define(schemeString, schemeString, parent); |
| // schemes.add(scheme); |
| // |
| // if (successors == 0) { |
| // return; |
| // } |
| // |
| // createScheme(bindingManager, schemeString, successors - 1, schemes); |
| // } |
| // |
| // /** |
| // * The binding manager for the currently running test. <code>null</code> |
| // * if no test is running. |
| // */ |
| // private BindingManager bindingManager = null; |
| // |
| // /** |
| // * The command manager for the currently running test. <code>null</code> |
| // * if no test is running. |
| // */ |
| // private CommandManager commandManager = null; |
| // |
| // /** |
| // * The context manager for the currently running test. <code>null</code> |
| // * if no test is running. |
| // */ |
| // private ContextManager contextManager = null; |
| // |
| // /** |
| // * Constructs an instance of <code>CommandsPerformanceTest</code>. |
| // * |
| // * @param testName |
| // * Test's name. |
| // */ |
| // public CommandsPerformanceTest(final String name) { |
| // super(name); |
| // } |
| // |
| // /** |
| // * <p> |
| // * Sets up a sufficiently complex set of bindings. |
| // * </p> |
| // * <p> |
| // * At the time of writing, Eclipse's key binding set contains about five |
| // * hundred bindings. Of these, 140 specify platform information, while only |
| // * 5 specify locale information. About 40 are deletion markers. The deepest |
| // * point in the context tree is four levels. There are two schemes. |
| // * </p> |
| // * <p> |
| // * The test binding set contains five thousand bindings. About 1400 specify |
| // * either locale or platform information. Five hundred are deletion markers. |
| // * The deepest point in the context tree is 40 levels. There are twenty |
| // * schemes. |
| // * </p> |
| // * <p> |
| // * The depth of the locale and platform tree is the same in both real life |
| // * and the test case. It is difficult to imagine why the locale list would |
| // * ever be anything but four elements, or why the platform list would ever |
| // * be anything but three elements. |
| // * </p> |
| // * |
| // * @throws NotDefinedException |
| // * If something went wrong initializing the active scheme. |
| // */ |
| // protected final void doSetUp() throws NotDefinedException, Exception { |
| // super.doSetUp(); |
| // |
| // /* |
| // * The constants to use in creating the various objects. The platform |
| // * locale count must be greater than or equal to the number of deletion |
| // * markers. Deletion markers are typically created based on the platform |
| // * or locale. |
| // */ |
| // final int contextTreeDepth = 40; |
| // final int schemeDepth = 20; |
| // final int bindingCount = 5000; |
| // final int platformLocaleCount = 1400; |
| // final int deletionMarkers = 500; |
| // final String currentLocale = Locale.getDefault().toString(); |
| // final String currentPlatform = SWT.getPlatform(); |
| // |
| // // Set-up a table of modifier keys. |
| // final IKeyLookup lookup = KeyLookupFactory.getDefault(); |
| // final int modifierKeys0 = 0; |
| // final int modifierKeys1 = lookup.getAlt(); |
| // final int modifierKeys2 = lookup.getCommand(); |
| // final int modifierKeys3 = lookup.getCtrl(); |
| // final int modifierKeys4 = lookup.getShift(); |
| // final int modifierKeys5 = lookup.getAlt() | lookup.getCommand(); |
| // final int modifierKeys6 = lookup.getAlt() | lookup.getCtrl(); |
| // final int modifierKeys7 = lookup.getAlt() | lookup.getShift(); |
| // final int modifierKeys8 = lookup.getCommand() | lookup.getCtrl(); |
| // final int modifierKeys9 = lookup.getCommand() | lookup.getShift(); |
| // final int modifierKeys10 = lookup.getCtrl() | lookup.getShift(); |
| // final int modifierKeys11 = lookup.getAlt() | lookup.getCommand() |
| // | lookup.getCtrl(); |
| // final int modifierKeys12 = lookup.getAlt() | lookup.getCommand() |
| // | lookup.getShift(); |
| // final int modifierKeys13 = lookup.getAlt() | lookup.getCtrl() |
| // | lookup.getShift(); |
| // final int modifierKeys14 = lookup.getCommand() | lookup.getCtrl() |
| // | lookup.getShift(); |
| // final int modifierKeys15 = lookup.getAlt() | lookup.getCommand() |
| // | lookup.getCtrl() | lookup.getShift(); |
| // final int[] modifierKeyTable = { modifierKeys0, modifierKeys1, |
| // modifierKeys2, modifierKeys3, modifierKeys4, modifierKeys5, |
| // modifierKeys6, modifierKeys7, modifierKeys8, modifierKeys9, |
| // modifierKeys10, modifierKeys11, modifierKeys12, modifierKeys13, |
| // modifierKeys14, modifierKeys15 }; |
| // |
| // // Initialize the command manager. |
| // commandManager = new CommandManager(); |
| // |
| // // Initialize the contexts. |
| // contextManager = new ContextManager(); |
| // final List activeContextIds = new ArrayList(); |
| // createContext(contextManager, null, contextTreeDepth, activeContextIds); |
| // contextManager.setActiveContextIds(new HashSet(activeContextIds)); |
| // |
| // // Initialize the schemes. |
| // bindingManager = new BindingManager(contextManager, commandManager); |
| // final List schemes = new ArrayList(); |
| // createScheme(bindingManager, null, schemeDepth, schemes); |
| // bindingManager |
| // .setActiveScheme((Scheme) schemes.get(schemes.size() - 1)); |
| // |
| // // Create the deletion markers. |
| // final Binding[] bindings = new Binding[bindingCount]; |
| // for (int i = 0; i < deletionMarkers; i++) { |
| // /* |
| // * Set-up the locale and platform. These are based on the numbers |
| // * given above. |
| // */ |
| // String locale = null; |
| // String platform = null; |
| // |
| // if (i < platformLocaleCount) { |
| // switch (i % 4) { |
| // case 0: |
| // locale = currentLocale; |
| // break; |
| // case 1: |
| // platform = currentPlatform; |
| // break; |
| // case 2: |
| // locale = "gibberish"; |
| // break; |
| // case 3: |
| // platform = "gibberish"; |
| // break; |
| // } |
| // } |
| // |
| // // Build a key sequence. |
| // final char character = (char) ('A' + (i % 26)); |
| // final int modifierKeys = modifierKeyTable[(i / 26) |
| // % modifierKeyTable.length]; |
| // final KeyStroke keyStroke = KeyStroke.getInstance(modifierKeys, |
| // character); |
| // final KeySequence keySequence = KeySequence.getInstance(keyStroke); |
| // |
| // // Build the other parameters. |
| // final String schemeId = ((Scheme) schemes.get(i % schemes.size())) |
| // .getId(); |
| // final String contextId = (String) activeContextIds.get(i |
| // % activeContextIds.size()); |
| // final int type = (i % 2); |
| // |
| // // Construct the binding. |
| // final Binding binding = new KeyBinding(keySequence, null, schemeId, |
| // contextId, locale, platform, null, type); |
| // bindings[i] = binding; |
| // } |
| // |
| // /* |
| // * Now create the regular bindings. By using the same loop structure and |
| // * resetting the index to zero, we ensure that the deletion markers will |
| // * actually delete something. |
| // */ |
| // for (int i = 0; i < bindingCount - deletionMarkers; i++) { |
| // /* |
| // * Set-up the locale and platform for those bindings that will not |
| // * be used to match the above deletion markers. These are based on |
| // * the numbers given above. |
| // */ |
| // String locale = null; |
| // String platform = null; |
| // |
| // if ((i > deletionMarkers) && (i < platformLocaleCount)) { |
| // switch (i % 4) { |
| // case 0: |
| // locale = currentLocale; |
| // break; |
| // case 1: |
| // platform = currentPlatform; |
| // break; |
| // case 2: |
| // locale = "gibberish"; |
| // break; |
| // case 3: |
| // platform = "gibberish"; |
| // break; |
| // } |
| // } |
| // |
| // // Build a key sequence. |
| // final char character = (char) ('A' + (i % 26)); |
| // final int modifierKeys = modifierKeyTable[(i / 26) |
| // % modifierKeyTable.length]; |
| // final KeyStroke keyStroke = KeyStroke.getInstance(modifierKeys, |
| // character); |
| // final KeySequence keySequence = KeySequence.getInstance(keyStroke); |
| // |
| // // Build the other parameters. |
| // final String commandId = "command" + i; |
| // final String schemeId = ((Scheme) schemes.get(i % schemes.size())) |
| // .getId(); |
| // final String contextId = (String) activeContextIds.get(i |
| // % activeContextIds.size()); |
| // final int type = (i % 2); |
| // |
| // // Construct the binding. |
| // final Command command = commandManager.getCommand(commandId); |
| // final ParameterizedCommand parameterizedCommand = new ParameterizedCommand( |
| // command, null); |
| // final Binding binding = new KeyBinding(keySequence, |
| // parameterizedCommand, schemeId, contextId, locale, |
| // platform, null, type); |
| // bindings[i + deletionMarkers] = binding; |
| // } |
| // bindingManager.setBindings(bindings); |
| // } |
| // |
| // protected final void doTearDown() throws Exception { |
| // bindingManager = null; |
| // commandManager = null; |
| // contextManager = null; |
| // super.doTearDown(); |
| // } |
| // |
| // /** |
| // * <p> |
| // * Tests how long it takes to access the cache if no conditions have |
| // * changed. It measures how long it takes to look up the computation from |
| // * the cache one million times. |
| // * </p> |
| // * |
| // * @throws ParseException |
| // * If "CTRL+F" can't be parsed for some strange reason. |
| // */ |
| // public final void testBindingCacheHitHard() throws ParseException { |
| // // Constants |
| // final int cacheHits = 1000000; |
| // final KeySequence keySequence = KeySequence.getInstance("CTRL+F"); |
| // |
| // // Compute once. |
| // bindingManager.getPartialMatches(keySequence); |
| // |
| // // Time how long it takes to access the cache; |
| // startMeasuring(); |
| // for (int i = 0; i < cacheHits; i++) { |
| // bindingManager.getPartialMatches(keySequence); |
| // } |
| // stopMeasuring(); |
| // commitMeasurements(); |
| // assertPerformance(); |
| // } |
| // |
| // /** |
| // * <p> |
| // * Tests how long it takes to access the cache if no conditions have |
| // * changed. It measures how long it takes to look up the computation from |
| // * the cache one million times. In this test, the look-up is done in reverse -- |
| // * from command identifier to trigger. |
| // * </p> |
| // * |
| // * @throws ParseException |
| // * If "CTRL+F" can't be parsed for some strange reason. |
| // */ |
| // public final void testBindingCacheHitHardReverse() throws ParseException { |
| // // Constants |
| // final int cacheHits = 1000000; |
| // final KeySequence keySequence = KeySequence.getInstance("CTRL+F"); |
| // |
| // // Compute once. |
| // bindingManager.getPartialMatches(keySequence); |
| // |
| // // Time how long it takes to access the cache; |
| // startMeasuring(); |
| // for (int i = 0; i < cacheHits; i++) { |
| // bindingManager.getActiveBindingsFor((ParameterizedCommand) null); |
| // } |
| // stopMeasuring(); |
| // commitMeasurements(); |
| // assertPerformance(); |
| // } |
| // |
| // /** |
| // * <p> |
| // * Tests how long it takes to access the cache if the conditions have |
| // * changed, but the cache contains a matching entry. It measures how long it |
| // * takes to look up the computation from the cache forty thousand times. |
| // * </p> |
| // * |
| // * @throws ParseException |
| // * If "CTRL+F" can't be parsed for some strange reason. |
| // */ |
| // public final void testBindingCacheHitSoft() throws ParseException { |
| // // Constants |
| // final int cacheHits = 10000; |
| // final KeySequence keySequence = KeySequence.getInstance("CTRL+F"); |
| // |
| // // Compute once for each context set. |
| // final Set contextSet1 = contextManager.getActiveContextIds(); |
| // bindingManager.getPartialMatches(keySequence); |
| // final List contextList = new ArrayList(contextSet1); |
| // contextList.remove(contextList.size() - 1); |
| // final Set contextSet2 = new HashSet(contextList); |
| // contextManager.setActiveContextIds(contextSet2); |
| // bindingManager.getPartialMatches(keySequence); |
| // |
| // // Time how long it takes to access the cache; |
| // startMeasuring(); |
| // for (int i = 0; i < cacheHits; i++) { |
| // if ((i % 2) == 0) { |
| // contextManager.setActiveContextIds(contextSet1); |
| // } else { |
| // contextManager.setActiveContextIds(contextSet2); |
| // } |
| // bindingManager.getPartialMatches(keySequence); |
| // } |
| // stopMeasuring(); |
| // commitMeasurements(); |
| // assertPerformance(); |
| // } |
| // |
| // /** |
| // * <p> |
| // * Tests how long it takes to do a full computation (i.e., a cache miss) on |
| // * an exceptionally large set of bindings. The binding set tries to mimick |
| // * some of the same properties of a "real" binding set. |
| // * </p> |
| // * |
| // * @throws ParseException |
| // * If "CTRL+F" can't be parsed for some strange reason. |
| // */ |
| // public final void testBindingCacheMissLarge() throws ParseException { |
| // // Constants |
| // final KeySequence keySequence = KeySequence.getInstance("CTRL+F"); |
| // |
| // // Time how long it takes to solve the binding set. |
| // startMeasuring(); |
| // bindingManager.getPartialMatches(keySequence); |
| // stopMeasuring(); |
| // commitMeasurements(); |
| // assertPerformance(); |
| // } |
| //} |
