| /******************************************************************************* |
| * Copyright (c) 2000, 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.jdt.core.tests.performance; |
| |
| import java.io.PrintStream; |
| import java.text.NumberFormat; |
| |
| import junit.framework.*; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.jdt.core.IField; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IMethod; |
| import org.eclipse.jdt.core.IOrdinaryClassFile; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.search.*; |
| import org.eclipse.jdt.core.tests.model.AbstractJavaModelTests; |
| import org.eclipse.jdt.internal.core.search.processing.IJob; |
| |
| /** |
| * Performance test suite which covers all main search requests: |
| * <ul> |
| * </ul> |
| * |
| * Note that this test suite was not supposed to be included in releng performance tests |
| * as it would take too much time to be run... |
| */ |
| @SuppressWarnings("rawtypes") |
| public class FullSourceWorkspaceCompleteSearchTests extends FullSourceWorkspaceSearchTests { |
| |
| // Tests counters |
| private static int TESTS_COUNT = 0; |
| private final static int ITERATIONS_COUNT = 0; |
| |
| // Log file streams |
| private static PrintStream[] LOG_STREAMS = new PrintStream[DIM_NAMES.length]; |
| |
| // Verify VM memory arguments: should be -Xmx256M -Xms256M |
| final static long MAX_MEM = 512L * 1024 * 1024; |
| |
| static { |
| // org.eclipse.jdt.internal.core.search.processing.JobManager.VERBOSE = true; |
| // TESTS_NAMES = new String[] { "testSearchField" }; |
| } |
| |
| /* |
| * Specific way to build test suite. |
| * We need to know whether test perf indexing is in list to allow |
| * index manager disabling. |
| * CAUTION: If test perf indexing is not included in test suite, |
| * then time for other tests may include time spent to index files! |
| */ |
| public static Test suite() { |
| Test suite = buildSuite(testClass()); |
| TESTS_COUNT = suite.countTestCases(); |
| createPrintStream(testClass(), LOG_STREAMS, TESTS_COUNT, null); |
| verifyVmArguments(); |
| return suite; |
| } |
| |
| private static Class testClass() { |
| return FullSourceWorkspaceCompleteSearchTests.class; |
| } |
| |
| /* |
| * Verify VM arguments when full tests are run (should be -Xmx512M) |
| */ |
| private static void verifyVmArguments() { |
| StringBuffer buffer = null; |
| NumberFormat floatFormat = NumberFormat.getNumberInstance(); |
| floatFormat.setMaximumFractionDigits(1); |
| long maxMem = Runtime.getRuntime().maxMemory(); // -Xmx |
| boolean tooMuch = false; |
| if (maxMem < (MAX_MEM*0.98) || (tooMuch = maxMem > (MAX_MEM*1.02))) { |
| if (buffer == null) buffer = new StringBuffer("WARNING: Performance tests results may be invalid !!!\n"); |
| buffer.append(" - "); |
| buffer.append(tooMuch ? "too much " : "not enough "); |
| buffer.append("max memory allocated ("); |
| buffer.append(floatFormat.format(((maxMem/1024.0)/1024.0))); |
| buffer.append("M)!\n"); |
| buffer.append(" => -Xmx"); |
| buffer.append(floatFormat.format(((MAX_MEM/1024.0)/1024.0))); |
| buffer.append("M should have been specified.\n"); |
| } |
| } |
| |
| /** |
| * @param name |
| */ |
| public FullSourceWorkspaceCompleteSearchTests(String name) { |
| super(name); |
| } |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| } |
| |
| /* (non-Javadoc) |
| * @see junit.framework.TestCase#tearDown() |
| */ |
| protected void tearDown() throws Exception { |
| |
| // End of execution => one test less |
| TESTS_COUNT--; |
| |
| // Log perf result |
| if (LOG_DIR != null) { |
| logPerfResult(LOG_STREAMS, TESTS_COUNT); |
| } |
| super.tearDown(); |
| } |
| |
| /** |
| * Simple search result collector: only count matches. |
| */ |
| class JavaSearchResultCollector extends SearchRequestor { |
| int count = 0; |
| public void acceptSearchMatch(SearchMatch match) throws CoreException { |
| this.count++; |
| } |
| } |
| |
| /** |
| * Job to measure times in same thread than index manager. |
| */ |
| class Measuring implements IJob { |
| boolean start; |
| Measuring(boolean start) { |
| this.start = start; |
| } |
| public boolean belongsTo(String jobFamily) { |
| return true; |
| } |
| public void cancel() { |
| // nothing to cancel |
| } |
| public void ensureReadyToRun() { |
| // always ready to do nothing |
| } |
| /** |
| * Execute the current job, answer whether it was successful. |
| */ |
| public boolean execute(IProgressMonitor progress) { |
| if (this.start) { |
| startMeasuring(); |
| } else { |
| stopMeasuring(); |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| return true; |
| } |
| public String getJobFamily() { |
| return "FullSourceWorkspaceCompleteSearchTests.Measuring"; |
| } |
| } |
| |
| protected void search(String patternString, int searchFor, int limitTo, JavaSearchResultCollector resultCollector) throws CoreException { |
| int matchMode = patternString.indexOf('*') != -1 || patternString.indexOf('?') != -1 |
| ? SearchPattern.R_PATTERN_MATCH |
| : SearchPattern.R_EXACT_MATCH; |
| SearchPattern pattern = SearchPattern.createPattern( |
| patternString, |
| searchFor, |
| limitTo, |
| matchMode | SearchPattern.R_CASE_SENSITIVE); |
| new SearchEngine().search( |
| pattern, |
| new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()}, |
| SearchEngine.createWorkspaceScope(), |
| resultCollector, |
| null); |
| } |
| |
| protected void search(IJavaElement element, int limitTo, JavaSearchResultCollector resultCollector) throws CoreException { |
| SearchPattern pattern = SearchPattern.createPattern( |
| element, |
| limitTo, |
| SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE); |
| new SearchEngine().search( |
| pattern, |
| new SearchParticipant[] {SearchEngine.getDefaultSearchParticipant()}, |
| SearchEngine.createWorkspaceScope(), |
| resultCollector, |
| null); |
| } |
| |
| /** |
| * Clean last category table cache |
| * @param type Tells whether previous search was a type search or not |
| * @param resultCollector result collector to count the matches found |
| */ |
| protected void cleanCategoryTableCache(boolean type, JavaSearchResultCollector resultCollector) throws CoreException { |
| long time = System.currentTimeMillis(); |
| if (type) { |
| search("foo", FIELD, DECLARATIONS, resultCollector); |
| } else { |
| search("Foo", TYPE, DECLARATIONS, resultCollector); |
| } |
| if (DEBUG) System.out.println("Time to clean category table cache: "+(System.currentTimeMillis()-time)); |
| } |
| |
| /** |
| * Performance tests for search types in workspace: |
| * <ul> |
| * <li>declarations using string pattern</i> |
| * <li>references using string pattern</i> |
| * <li>delcarations using java element pattern</i> |
| * <li>references using java element pattern</i> |
| * </ul> |
| */ |
| public void testSearchStringTypeDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "Object"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, TYPE, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for type '"+name+"' in workspace."); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| cleanCategoryTableCache(true, resultCollector); |
| runGc(); |
| startMeasuring(); |
| search(name, TYPE, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchStringTypeReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "Object"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, TYPE, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for type '"+name+"' in workspace."); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| cleanCategoryTableCache(true, resultCollector); |
| runGc(); |
| startMeasuring(); |
| search(name, TYPE, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementTypeDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get Object type |
| IOrdinaryClassFile object = getClassFile(JDT_CORE_PROJECT, "rt.jar", "java.lang", "Object.class"); |
| IType type = object.getType(); |
| assertTrue("Cannot find type 'Object'", type != null && type.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(type, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for type '"+type.getElementName()+"' in workspace."); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| cleanCategoryTableCache(true, resultCollector); |
| runGc(); |
| startMeasuring(); |
| search(type, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementTypeReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get Object type |
| IOrdinaryClassFile object = getClassFile(JDT_CORE_PROJECT, "rt.jar", "java.lang", "Object.class"); |
| IType type = object.getType(); |
| assertTrue("Cannot find type 'Object'", type != null && type.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(type, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for type '"+type.getElementName()+"' in workspace."); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| cleanCategoryTableCache(true, resultCollector); |
| runGc(); |
| startMeasuring(); |
| search(type, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| |
| /** |
| * Performance tests for search fields in workspace: |
| * <ul> |
| * <li>declarations using string pattern</i> |
| * <li>references using string pattern</i> |
| * <li>delcarations using java element pattern</i> |
| * <li>references using java element pattern</i> |
| * </ul> |
| */ |
| public void testSearchStringFieldDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "name"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, FIELD, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for field '"+name+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(name, FIELD, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchStringFieldReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "name"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, FIELD, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for field '"+name+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(name, FIELD, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementFieldDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get field 'name' |
| IType type = JDT_CORE_PROJECT.findType("org.eclipse.jdt.internal.core", "JavaElement"); |
| assertTrue("Cannot find compilation unit 'JavaElement.java' in 'org.eclipse.jdt.internal.core'", type != null && type.exists()); |
| IField field = type.getField("name"); |
| assertTrue("Cannot find field equals", field != null && field.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(field, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for field '"+field.getElementName()+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(field, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementFieldReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get field 'name' |
| IType type = JDT_CORE_PROJECT.findType("org.eclipse.jdt.internal.core", "JavaElement"); |
| assertTrue("Cannot find compilation unit 'JavaElement.java' in 'org.eclipse.jdt.internal.core'", type != null && type.exists()); |
| IField field = type.getField("name"); |
| assertTrue("Cannot find field equals", field != null && field.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(field, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for field '"+field.getElementName()+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(field, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| |
| /** |
| * Performance tests for search methods in workspace: |
| * <ul> |
| * <li>declarations using string pattern</i> |
| * <li>references using string pattern</i> |
| * <li>delcarations using java element pattern</i> |
| * <li>references using java element pattern</i> |
| * </ul> |
| */ |
| public void testSearchStringMethodDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "equals"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, METHOD, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for method '"+name+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(name, METHOD, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchStringMethodReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "equals"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, METHOD, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for method '"+name+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(name, METHOD, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementMethodDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get method 'equals' |
| IOrdinaryClassFile object = getClassFile(JDT_CORE_PROJECT, "rt.jar", "java.lang", "Object.class"); |
| IType objectType = object.getType(); |
| IMethod method = objectType.getMethod("equals", new String[] { "Ljava.lang.Object;" }); |
| assertTrue("Cannot find method equals", method != null && method.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(method, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for method '"+method.getElementName()+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(method, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementMethodReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get method 'equals' |
| IOrdinaryClassFile object = getClassFile(JDT_CORE_PROJECT, "rt.jar", "java.lang", "Object.class"); |
| IType objectType = object.getType(); |
| IMethod method = objectType.getMethod("equals", new String[] { "Ljava.lang.Object;" }); |
| assertTrue("Cannot find method equals", method != null && method.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(method, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for method '"+method.getElementName()+"' in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(method, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| |
| /** |
| * Performance tests for search constructors in workspace: |
| * <ul> |
| * <li>declarations using string pattern</i> |
| * <li>references using string pattern</i> |
| * <li>delcarations using java element pattern</i> |
| * <li>references using java element pattern</i> |
| * </ul> |
| */ |
| public void testSearchStringConstructorDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "()"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, CONSTRUCTOR, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for default constructor in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(name, CONSTRUCTOR, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchStringConstructorReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Warm up |
| String name = "()"; |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(name, CONSTRUCTOR, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for default constructor in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(name, CONSTRUCTOR, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementConstructorDeclarations() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get constructor 'equals' |
| IOrdinaryClassFile object = getClassFile(JDT_CORE_PROJECT, "rt.jar", "java.lang", "Object.class"); |
| IType objectType = object.getType(); |
| IMethod constructor = objectType.getMethod("Object", new String[0]); |
| assertTrue("Cannot find default constructor", constructor != null && constructor.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(constructor, DECLARATIONS, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" declarations for default constructor in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(constructor, DECLARATIONS, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| public void testSearchJavaElementConstructorReferences() throws CoreException { |
| |
| // Wait for indexing end |
| AbstractJavaModelTests.waitUntilIndexesReady(); |
| |
| // Get constructor 'equals' |
| IOrdinaryClassFile object = getClassFile(JDT_CORE_PROJECT, "rt.jar", "java.lang", "Object.class"); |
| IType objectType = object.getType(); |
| IMethod constructor = objectType.getMethod("Object", new String[0]); |
| assertTrue("Cannot find default constructor", constructor != null && constructor.exists()); |
| |
| // Warm up |
| JavaSearchResultCollector resultCollector = new JavaSearchResultCollector(); |
| search(constructor, REFERENCES, resultCollector); |
| NumberFormat intFormat = NumberFormat.getIntegerInstance(); |
| System.out.println(" - "+intFormat.format(resultCollector.count)+" references for default constructor in workspace"); |
| |
| // Measures |
| for (int i=0; i<ITERATIONS_COUNT; i++) { |
| // clean before test |
| cleanCategoryTableCache(false, resultCollector); |
| runGc(); |
| |
| // test |
| startMeasuring(); |
| search(constructor, REFERENCES, resultCollector); |
| stopMeasuring(); |
| } |
| |
| // Commit |
| commitMeasurements(); |
| assertPerformance(); |
| } |
| } |