Attachment #55133 for bug #165936

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 165936
Collapse All | Expand All




package org.eclipse.hyades.use.cases.auto.profiling.logging;

import java.util.ArrayList;
import java.util.Hashtable;

import org.eclipse.hyades.use.cases.auto.common.Logger;

import org.eclipse.tptp.test.auto.gui.internal.runner.AutoGUIVerificationHook;

/**
 * Generated code for the test suite <b>Platform.UI.ProfilingPerspective.Launch.Part5</b> located at
 * <i>/org.eclipse.hyades.use.cases/gui/Profiling_and_Logging/Launch/Platform.UI.ProfilingPerspective.Launch.Part5.testsuite</i>.
 * Please review the Test Overview and adjust varaible wait times (under the Behaviour Tab) before starting.
 */
	public class PlatformUIProfilingPerspectiveLaunchPart5 extends
 * Author: Mike Hao
 */
public class PlatformUIProfilingPerspectiveLaunchPart5 extends
		AutoGUIVerificationHook {

	/**
	 * Constructor for PlatformUIProfilingPerspectiveLaunchPart5.  An instance of this class is created to
	 * test a test method.
	 *
	 * @param testMethodName The test method to be tested.

	 * @see junit.framework.TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		Logger.getInstance().close();
	}

	/**
	* TestJavaAppLaunchShortCut
	*  
	*  A test to ensure that the shortcut to launching a Profile of a Java application
	*  succeeds and collectes data correctly
	*  
	*  1) Import a Java Application (done in test ImportJavaApp)
	*  2) Select the .java file and Select Profile As >Java Application
	*  3) Select Execution Statistics
	*  4) Select Profile
	*  5) Verify that the correct Execution Statistics were collected
	*  
	*  This method performs the verification in Step 5)
	*  
	* @param arg0 The Viewpart selected in the View
	* @throws Exception
	*/
	public void verifyCollectedData(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyCollectedData");
		verifyCallsDetails(arg0, new String[]{"HelloWorld()"}, new int[] {1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyCollectedData");
	}

	/**
	* Verify Java Application launch configuration automatic creation.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Remove all existing Java Application launch configurations.</li>
	* <li>Create a new Java Project in your workspace containing a class with a main() method.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Application</b>.</li>    
	* <li>Verify the launch configuration dialog opens with valid defaults.</li>   
	* <li>Add some filter to the profiled class. Click <b>Profile</b></li>     
	* <li>Verify the application is profiled and contains valid filtered data.</li> 
	* </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/		
	public void verifyLaunchShortCutWithFilter(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLaunchShortCutWithFilter");	
		verifyCallsDetails(arg0, new String[]{"HelloWorld()"}, new int[]{1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLaunchShortCutWithFilter");
	}

	/**
	* Verify Java Application launch shortcut with selection.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Remove all existing Java Application launch configurations.</li>
	* <li>Create a new Java Project in your workspace containing a class with a main() method.</li>
	* <li>Create a Java Application profile configuration for this new Java class with a name.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Application</b>.</li>
	* <li>Verify the launch configuration dialog appears with the existing launch configuration.</li>
	* <li>Create a second Java Application profile configuration for the same class with different name and profiling settings.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Application</b>.</li>    
	* <li>Verify a dialog appears with two launch configurations available.</li>   
	* <li>Select one configuration and Click <b>Ok</b></li>     
	* <li>Verify the application is profiled with the selected configuration.</li> 
	* </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/		
	public void verifyLaunchConfigName(org.eclipse.swt.widgets.Shell arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLaunchConfigName");	
		assertNotNull(VerifyHookUtil.findControl(arg0, VerifyHookUtil.TEXT_CONTROL_TYPE, "HelloWorldNoFilter"));
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLaunchConfigName");
	}

	/**
	* Verify Java Application launch shortcut with selection.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Remove all existing Java Application launch configurations.</li>
	* <li>Create a new Java Project in your workspace containing a class with a main() method.</li>
	* <li>Create a Java Application profile configuration for this new Java class with a name.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Application</b>.</li>
	* <li>Verify the launch configuration dialog appears with the existing launch configuration.</li>
	* <li>Create a second Java Application profile configuration for the same class with different name and profiling settings.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Application</b>.</li>    
	* <li>Verify a dialog appears with two launch configurations available.</li>   
	* <li>Select one configuration and Click <b>Ok</b></li>     
	* <li>Verify the application is profiled with the selected configuration.</li> 
	* </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/		
	public void verifyShortCutSelection(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
        Logger.getInstance().logMessage(Logger.INFO, "Entering verifyShortCutSelection");	
		verifyCallsDetails(arg0, new String[]{"HelloWorld()"}, new int[]{1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyShortCutSelection");
	}

	/**
	* Verify Java Applet launch configuration automatic creation.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Remove all existing Java Applet launch configurations.</li>
	* <li>Create a new Java Project in your workspace containing a class that extends Applet.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Applet</b>.</li>    
	* <li>Verify the launch configuration dialog opens with valid defaults. Click <b>Profile</b></li>    
	* <li>Verify the application is profiled and contains valid data.</li> 
	* </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/		
	public void verifyAppletLaunchShortCut(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyAppletLaunchShortCut");	
		verifyCallsDetails(arg0, new String[]{"TestApplet()"}, new int[]{1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyAppletLaunchShortCut");

	}
	

	/**
	 *  A private helper method which verifies the information in a Statistics View
	 *  of the Profiling and Logging Perspective.
	 *  It takes in the number of calls we are expecting and compares them to what is
	 *  actually there.
	 *  
	 * @param tree The tree input
	 * @param treeItems The TreeItems in tree
	 * @param names The names of the methods we are looking for
	 * @param callTimes The expected callTimes
	 * @param equal boolean of whether we expect them to be equal or not
	 */
	* @throws Exception
	*/	
	public void verifyJavaAppArgs(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyJavaAppArgs");	
		verifyConsoleMessage(arg0, new String[] {"arg1", "-arg2", "arg3"});		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyJavaAppArgs");
	}

	/**
	* Verify Java Applet launch configuration automatic creation.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Remove all existing Java Applet launch configurations.</li>
	* <li>Create a new Java Project in your workspace containing a class that extends Applet.</li>
	* <li>In the <b>Package Explorer</b> of the <b>Java Perspective</b>, right click on the class, select <b>Profile As</b>, then <b>Java Applet</b>.</li>    
	* <li>Verify the launch configuration dialog opens with valid defaults. Click <b>Profile</b></li>    
	* <li>Verify the application is profiled and contains valid data.</li> 
	* </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/	
	public void verifyJUnitLaunchShortCut(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		boolean doesExist = false;
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyJUnitFailure");
		Composite junitView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (junitView);
		Control[] tables = VerifyHookUtil.findAllControl(junitView, VerifyHookUtil.TABLE_CONTROL_TYPE, null);
		for (int i = 0; i < tables.length; i++) 
		{
			TableItem item= VerifyHookUtil.findTableItem((Table)tables[i], 0, "junit.framework.AssertionFailedError");
			if (item !=null){
				doesExist = true;
				break;
			}
		}
		assertTrue(doesExist);
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyJUnitFailure");
	}
	
	/**
	* Verify profiling filters via Properties.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Click on <b>Profile</b> button from the tool bar.</li>
	* <li>Double click on <b>External Java Application</b>.</li>
	* <li>In the <b>Main</b> tab, browse for a class name, and then click <b>Apply</b> button.</li>    
	* <li>Switch to <b>Profile</b> tab.</li>  
	* <li>Select <b>Execution History</b>, then click on the <b>Edit</b> button.<li>    
	* <li>Click <b>Next</b> in the resulting dialog.</li>
	* <li>Add some filters to the profiling set.</li>
	* <li>Finish the wizard, then click on the <b>Profile</b> button.</li>
	* <li>The application should be profiled.</li> 
	* <li>Right click on the profile agent and select <b>Properties</b>.</li>
	* <li>Find the filters page and modify the filter set. Click <b>Finish.</b></li>
	* <li>Verify all the data collected after the filter change complies with the changed filters.</li> 
	* </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #10
	* @throws Exception
	*/		
	public void verifyFilterViaProperties(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		  Logger.getInstance().logMessage(Logger.INFO, "Entering verifyFilterViaProperties");
			
		  Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		  assertNotNull (memoryStatisticsView);				
		  Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		  assertNotNull (tree);	
		  TreeItem[] treeItems = tree.getItems();		
		  
			for(int i = 0; i < treeItems.length; i++){
				Logger.getInstance().logMessage(Logger.INFO, treeItems[i].getText());
			}

		  assertTrue(getTreeItemIndex(treeItems, "methodB() void") == -1 );	
					
		  Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyFilterViaProperties");

	}
	


	/**
	* Verify profiling agent paused and then terminated status.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Click on <b>Profile</b> button from the tool bar.</li>
    * <li>Double click on <b>External Java Application</b>.</li>
    * <li>In the <b>Main</b> tab, browse for a class name, and then click <b>Apply</b> button.</li>    
    * <li>Click <b>Profile</b> button.</li>   
    * <li>Right click on the agent, and select <b>Pause</b>.</li>
    * <li>Right click on the agent, and select <b>Terminate</b>.</li>	   
    * <li>Verify agent is terminated.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #7
	* @throws Exception
	*/		
	public void verifyPausedTerminated(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyPausedTerminate");
		 verifyAgentStatus(arg0, "terminated");					
		 Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyPausedTerminate");
	}
		
	private void verifyAgentStatus(org.eclipse.ui.IViewPart arg0, String status){
		boolean found = false;
		Composite profileMonitor = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (profileMonitor);		
		
		Tree tree = (Tree)VerifyHookUtil.findControl(profileMonitor, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		 
		TreeItem[] treeItemSelected  = tree.getSelection();	
			
		for(int i = 0; i < treeItemSelected.length; i++){
			if (treeItemSelected[i].getText().indexOf(status) >= 0){
				found = true;
			    break;
			}
		}	
		assertTrue(found);
	}
	
	private void verifyCallsDetails(org.eclipse.ui.IViewPart arg0, String[] names, int[] callTimes, boolean equal)
	{	
		Composite statisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (" The Statistics View Contains no data", statisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findAllControl(statisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null)[1];
		assertNotNull (" The Selected Tree is null", tree);	
		TreeItem[] treeItems = tree.getItems();
		
		int callsClmnIndex = getTreeColumnIndex(tree, "Calls");

		}
	}

	/**
	 * A private helper method meant to return the index of a given item in a tree
	 * It takes in the Array of TreeItems and the String we are looking for and returns
	 * the int representation of the index of the given String in the TreeItem array.
	 * 
	 * @param items The Array of TreeItems to search
	 * @param item The String representation of the item we are looking for
	 * @return an int representing the index of item in items
	 */
	private int getTreeItemIndex(TreeItem[] items, String item)
	{
		int index = -1;		
		
		for(int i = 0; i < items.length; i++){		
			if(items[i].getText().trim().equals(item.trim())){
				index = i;

		return index;	
	}
	
	/**
	 *  A private helper method which takes in an array of ints and an index
	 *  and returns true if index is in nums and false otherwise.
	 *  
	 * @param index The int we are looking for
	 * @param nums The array of ints we are looking in
	 * @return true if index is in nums, false otherwise
	 */
	private boolean isIn(int index, int[] nums)
	{
		for(int i = 0; i < nums.length; i++)
		{
			if(index == nums[i])
			{
				return true;
			}
		}
		return false;
	}
	/**
	 * A private helper method which returns a Hashtable of the indices
	 * of the given names in the selected Tree.
	 * 
	 * @param items The given TreeItems to search
	 * @param names The names to search for
	 * @return indices, a hashtable representation of the indices of names in items
	 */
	private Hashtable getTreeItemIndexes(TreeItem[] items, String[] names)
	{		
		
		Hashtable indices = new Hashtable();
		

		}						
		return indices;	
	}
	/**
	 * A private helper method which returns just one index of the given 
	 * column header in the tree.
	 * 
	 * @param tree The tree view we are seraching in
	 * @param column The cokumn header we are seraching for
	 * @return an int representation of the index of the column in the view
	 */
	private int getTreeColumnIndex(Tree tree, String column){
		int index = -1;
		

	
	
	/**
	* A Verification hook called in multiple test cases which checks the
	* Agent's status to ensure that profiling has terminated before we open 
	* a statistical view.
	*  
	* @param arg0 the ViewPart selected in the View 
	* @throws Exception
	*/
	public void verifyTerminatedStatus(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyTerminatedStatus");
		verifyAgentStatus(arg0, "terminated");	
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyTerminatedStatus");
	}
	
	/**
	 * A private helper method to verify the String-listed status of the Agent.
	 * It takes in a status to compare to and seerts that this is also the status
	 * present during the verification.
	 * 
	 * @param arg0 The ViewPart selected in the View
	 * @param status The String representation of the status we are expecting
	 */
	private void verifyAgentStatus(org.eclipse.ui.IViewPart arg0, String status)
	{
		boolean found = false;
		Composite profileMonitor = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull ("The profiling monitor selected is null", profileMonitor);		
		VerifyHookUtil.widgetDump(profileMonitor);
		Tree tree = (Tree)VerifyHookUtil.findControl(profileMonitor, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull ("The tree in this view is null",tree);	
		TreeItem[] treeItemSelected  = tree.getSelection();	
			
		for(int i = 0; i < treeItemSelected.length; i++)
		{
			if (treeItemSelected[i].getText().indexOf(status) >= 0){
				found = true;
				
			    break;
			}
		}	
		assertTrue( found);
	}

	/**
	 * A verification of the data collected when we launch a Java application with
	 * arguments using the shortcut
	 * 
	 * @param arg0 The ViewPart selected in the View
	 * @throws Exception
	 */
	public void verifyTestJavaAppLaunchShortCut(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyTestJavaAppLaunchShortCut");
		verifyCallsDetails(arg0, new String[]{"HelloWorld()"}, new int[] {1}, true);
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyTestJavaAppLaunchShortCut");
	}

	/**
	* TestJavaAppWithFiltersShortCut
	*  
	*  A test of the functionality of the profiling launch configuration
	*  with filters.
	*  
	*  1) Import a Java Application (done in test ImportJavaApp)
	*  2) Select the .java file and Select Profile As> Java Application
	*  3) Select only Executioin statistics
	*  4) Edit filters
	*  5) Add a new Filter which excludes the rootMethod1 in the HelloWorld Class
	*  6) Profile
	*  7) Verify that the rootMethod1 has been omitted from the Execution Statistics View
	*  
	*  The method below performs the verificationin Step 7)
	* @param arg0 The ViewPart selected in the View
	* @throws Exception
	*/
	public void verifyTestJavaAppWIthFiltersShortCut(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyTestJavaAppWIthFiltersShortCut");
		verifyNotInList(arg0, new String[]{"rootMethod1()"});	
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyTestJavaAppWIthFiltersShortCut");
	}
	
	/**
	 * A private helper method to verify that the given methodName was excluded from 
	 * the data collection due to filtering.
	 * 
	 * @param arg0, the View selected
	 * @param names, the list of names we want to ensure are not in the View
	 */
	private void verifyNotInList(org.eclipse.ui.IViewPart arg0, String[] names ){
	
	Composite statisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
	assertNotNull (" The Statistics View is null", statisticsView);				
	Tree tree = (Tree)VerifyHookUtil.findAllControl(statisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null)[1];
	assertNotNull ("There is no tree Selected in the View", tree);	
	TreeItem[] treeItems = tree.getItems();
	
	Hashtable indices = getTreeItemIndexes(treeItems, names); 		
	
	for (int i = 0; i < names.length; i++) 
	{
		Integer inx = (Integer)indices.get(names[i]);
		// need to assert that it is null because we want to ensure it has been excluded
		// from the list
		assertNull("Method " + names[i] + " was found in error", inx);	
	}
}

	/**
	* TestJavaAppMultiConfigs
	*  
	*  This method performs the verification in Step 6)
	*  
	* @param arg0 The Shell selected
	* @throws Exception
	*/
	public void verifyConfigName(org.eclipse.swt.widgets.Shell arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyConfigName");
		assertNotNull(VerifyHookUtil.findControl(arg0, VerifyHookUtil.TEXT_CONTROL_TYPE, "HelloWorld"));
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyConfigName");
	}

	/**
	* TestJavaAppMultiConfigs
	*  
	*  This method performs the verification in Step 11)
	*  
	* @param arg0 The Shell selected
	* @throws Exception
	*/
	public void verifyBothConfigs(org.eclipse.swt.widgets.Shell arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyBothConfig");	
		boolean doesExist = false;				
		Control tables[] = VerifyHookUtil.findAllControl(arg0, VerifyHookUtil.TABLE_CONTROL_TYPE, null);
	
		for(int i = 0; i < tables.length; i++)
		{
			TableItem tableItem = VerifyHookUtil.findTableItem((Table)tables[i], 0, "HelloWorld");
			TableItem tableItem2 = VerifyHookUtil.findTableItem((Table)tables[i], 0, "HelloWorld_2");
			if (tableItem != null && tableItem2 !=null)
			{
				doesExist = true;
				
			}
			assertTrue("The Specified Launch config is missing one or more" , doesExist);
			Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyBothConfig");	
		}
	}

	/**
	* TestJavaAppMultiConfigs
	*  
	*  A Test to ensure that multiple Launch configuratoins can be created for
	*  the same class (Profiling Launch configurations).
	*  
	*  1) Select Profile...
	*  2) Create a new Profile launch configuration for a Java Application
	*  3) Name it HelloWorld
	*  4) Save it
	*  5) Select the Application in the Navigator view and Select Profile As> Java Application
	*  6) Verify that the name of the application is HelloWorld
	*  7) Create a second Proflie Launch configurationfor the same application
	*  8) Name it HelloWorld_2 and select a different profiling set than HelloWorld
	*  9)  Save it
	*  10) Select the application and Select Profile As> Java Application
	*  11) Verify that both HelloWorld and HelloWorld_2 are there and Select HelloWorld
	*  12) Verify that the statistics specified in HelloWorld are collected correctly
	*  
	*  This method performs the verification in Step 12)
	*  
	* @param arg0 The ViewPart selected in the View
	* @throws Exception
	*/
	public void verifyExecutionStats(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyExecutionStats");	
		
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		assertTrue(" The Tree Selected contains no items", treeItems.length > 0);
		/* call to verify the instances collected in this view for this particualr app*/
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting  verifyExecutionStats");
		verifyAppInstances(tree, treeItems, "HelloWorld", 1, 1);
	}
	/**
	 * A private helper method 
	 * @param tree
	 * @param treeItems
	 * @param app
	 * @param totalExpected
	 * @param activeExpected
	 */
	private void verifyAppInstances(Tree tree, TreeItem[] treeItems, String app, int totalExpected, int activeExpected)
	{
	
		// in order to make the test case more flexible so it can be run on different machines, we allow a threshold of error for the 
		// hard-coded values for number of instances in StartStop
		
		int totalInstancesClmnIndex = getTreeColumnIndex(tree, "Total Instances");
		int liveInstancesClmnIndex = getTreeColumnIndex(tree, "Live Instances");	
		int appItemIndex = getTreeItemIndex(treeItems, app);		
		int appTotalInst = 0;
		int appLiveInst = 0;
	
		for(int i = 0; i < treeItems.length; i++)
		{
			if( i == appItemIndex )
			{				
				appTotalInst = Integer.parseInt((String)treeItems[i].getText(totalInstancesClmnIndex));
				appLiveInst = Integer.parseInt((String)treeItems[i].getText(liveInstancesClmnIndex));
				
			}		
		}	
		if (totalExpected > 5000)
		{
			// then we know we are in the StartStop case so we allow a threshold to make the tes more flexible
			assertTrue("<EXPECTED TOTAL INSTANCES ARE TOO FAR FROM THE ACTUAL VALUES>",(appTotalInst <= totalExpected + 500) && (appTotalInst >= totalExpected-500) );
			assertTrue("<EXPECTED ACTIVE INSTANCES ARE TOO FAR FROM THE ACTUAL VALUES>",(appLiveInst <= activeExpected + 500) && (appLiveInst >= activeExpected-500) );
		}
		else
		{		/* verify the Total Instances and Live Instances of App */
			assertTrue("<EXPECTED TOTAL INSTANCES>" + totalExpected + "<ACTUAL TOTAL INSTANCES> " + appTotalInst,appTotalInst == totalExpected);
			assertTrue("<EXPECTED ACTIVE INSTANCES>" + activeExpected + "<ACTUAL ACTIVE INSTANCES> " + appLiveInst, appLiveInst == activeExpected);
		}
	}

	/**
	* TestAggregatedAgentLaunch
	*  
	*  A test case to test the profiling of an application at multiple stages
	*  of execution and to verify the data collected at each stage.
	*  
	*  1)Select Profile> External Java Application
	*  2) Point to the AggregateAgent class in the project location/Resources
	*  3) Select Execution Time Analysis
	*  4) Profile
	*  5) Verify beofre you press enter in the console that the correct Methods have been profiled
	*  6) Press Enter
	*  7) Verify that in this second stage, the correct classes have been profiled
	*  
	*  
	*  This method performs the verification in Step 5)
	*  
	* @param arg0, the ViewPart selected in the View
	* @throws Exception
	*/
	public void verifyInitialCalls(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyInitialCalls");
		verifyCallsDetails(arg0, new String[] {"methodA() void", "methodB() void"}, new int[]{2, 2}, true);
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyInitialCalls");
	}

	/**
	* TestAggregatedAgentLaunch
	*  
	*  This method performs the verification in Step 7)
	*  
	* @param arg0 the ViewPart selected in the View
	* @throws Exception
	*/
	public void verifyCallsAfterStageTwo(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyCallsAfterStageTwo");
		verifyCallsDetails(arg0, new String[] {
				"flatMethod1() void", "flatMethod2() void"}, new int[]{1, 1}, true);
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyCallsAfterStageTwo");
	}
	
	/**
	* TestJavaAppletLaunchShortCut
	*  
	* @throws Exception
	*/
	public void verifyTestJavaAppletLaunchSHortCut(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyTestJavaAppletLaunchSHortCut");	
		verifyCallsDetails(arg0, new String[]{"paint(java.awt.Graphics) void"}, new int[]{1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyTestJavaAppletLaunchSHortCut");
	}

	/**
	* TestJavaAppArgs
	*  
	* @throws Exception
	*/
	public void verifyExecutionStatsArgs(org.eclipse.ui.IViewPart arg0)
	throws Exception{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyExecutionStatsArgs");	
		verifyCallsDetails(arg0, new String[]{"AppArgs()"}, new int[]{1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyExecutionStatsArgs");
		
	}
	/**
	 * A private helper method which verifies the information in the Console view
	 * By seraching for it in the Control selected.
	 * 
	 * @param arg0 The ViewPart selected in the View
	 * @param keywords The console output we are looking for
	 * @throws Exception
	 */
	
	private void verifyConsoleMessage(org.eclipse.ui.IViewPart arg0, String[] keywords)
	throws Exception
	{	
		Composite consoleComposite = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull ("There is no data in the console view", consoleComposite);			
		assertTrue ("Not found: " + keywords.toString(), VerifyHookUtil.verifyControlValue(consoleComposite, VerifyHookUtil.STYLED_TEXT_CONTROL_TYPE, keywords));
	}

	/**
	* TestJavaAppArgs
	*  
	*  This test is meant to verify the console information.
	*  
	* @param arg0 The ViewPart selected in the View
	* @throws Exception
	*/
	public void verifyConsolePrintout(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		{
			Logger.getInstance().logMessage(Logger.INFO, "Entering verifyConsolePrintout");	
			verifyConsoleMessage(arg0, new String[] {"-arg1", "-arg2", "-arg3"});		
			Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyConsolePrintout");
		}
	}
	/**
	 * A test meant to check on the profiling Data before the agent has been detached so we know
	 * that even after interaction (pressing Enter in StartStop), the detached agent should
	 * not collect any more data and we should be able to safely exclude ceratin methods from the 
	 * output as a verification
	 * 
	 * @param arg0 The View selected in the ViewPart
	 * @throws Exception
	 */
	public void verifyProfilingDataBefore(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyProfilingDataBefore");	
		verifyCallsDetails(arg0, new String[]{"main(java.lang.String [])void"}, new int[]{1}, true);		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyProfilingDataBefore");
	}
	/**
	 * A private helper method which performs the second stage verification, after 
	 * we have interacted with the console to produce more datat, ened to verify
	 * that this data was not collected in the Statistics view as the agent should be
	 * detached.
	 * 
	 * @param arg0 The ViewPart selected in the View
	 * @throws Exception
	 */
	public void verifyDataPausedTerminated(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		verifyNotInList(arg0, new String[]{"methodA()", "methodB()"});	
	}

	/**
	 * A verification method which checks the String representation of the
	 * agent status against what is expected.
	 * 
	 * @param arg0 The ViewPart selected in the View
	 * @throws Exception
	 */
	public void verifyDetachedStatus (org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyDetachedStatus");
		verifyAgentStatus(arg0, "detached");	
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyDetachedStatus");
	}

	/**
	 * TestJunitLaunchShortCut
	 * 
	 * This test is designed to ensure that launching a Junit test profile
	 * through the Profile As function produces correct collection of data.
	 * 
	 * 1) Create a Junit test inside a Java Project (performed by ImportJunitTest)
	 * 2) Select the Junit file and SElect Profile As> Junit Test
	 * 3) Verify that the Junit test is profiled and that the results of the
	 * Junit test are correctly diplayed in the Profiling Perspective.
	 * 
	 * This test is meant to perform the verification in Step 3)
	 * 
	 * @param arg0 The ViewPart selected in the View
	 * @throws Exception
	 */
	public void verifyJunitFailure(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		boolean doesExist = false;
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyJUnitFailure");
		Composite junitView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (junitView);
		Control[] tables = VerifyHookUtil.findAllControl(junitView, VerifyHookUtil.TABLE_CONTROL_TYPE, null);
		for (int i = 0; i < tables.length; i++) 
		{
			TableItem item= VerifyHookUtil.findTableItem((Table)tables[i], 0, "junit.framework.AssertionFailedError");
			if (item !=null){
				doesExist = true;
				break;
			}
		}
		assertTrue(doesExist);
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyJUnitFailure");
	}

}




package org.eclipse.hyades.use.cases.auto.profiling.logging;


import java.util.ArrayList;

import org.eclipse.hyades.use.cases.auto.common.Logger;
import org.eclipse.hyades.use.cases.auto.common.VerifyHookUtil;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.tptp.test.auto.gui.internal.runner.AutoGUIVerificationHook;

/**
 * Generated code for the test suite <b>Platform.UI.ProfilingPerspective.Launch.Part4</b> located at
 * <i>/org.eclipse.hyades.use.cases/gui/Profiling_and_Logging/Launch/Platform.UI.ProfilingPerspective.Launch.Part4.testsuite</i>.
 * 
 * Note: Prior to running these tests, testers must ensure that the wait time variables are configured accordingly. For an avergae speed, try
 * 1000, for slower amchines increase to 2000 or 3000 if you are getting failures. Some, such as those used for ProfilingLimitsCalls must be set higher.
 */
	public class PlatformUIProfilingPerspectiveLaunchPart4 extends
		AutoGUIVerificationHook {

	/**
	 * Constructor for PlatformUIProfilingPerspectiveLaunchPart4.  An instance of this class is created to
	 * test a test method.
	 *
	 * @param testMethodName The test method to be tested.

	 * @see junit.framework.TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		Logger.getInstance().close();
	}
	
	/**
	* Verify the profiling set removement warning.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Open a new profiling launch configuration.</li>
    * <li>Click the <b>Profiling</b> tab, then the <b>Overview</b> tab.</li>
    * <li>Select a profiling set that is shared by more than one launch configurations.</li>    
    * <li>Click <b>Remove</b> button.</li>   
    * <li>A warning dialog should show up with an appropriate message.</li>   
    * <li>Click <b>No</b></li> 
    * <li>Ensure the profiling set was not removed.</li>   
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/			
	public void verifyProfilingSetRemoveWarning(org.eclipse.swt.widgets.Shell arg0)
	throws Exception
	{
		boolean doesWarningExist = false;			
		
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyProfilingSetRemoveWarning");			
		
		Control[] labels = VerifyHookUtil.findAllControl(arg0, VerifyHookUtil.LABEL_CONTROL_TYPE, null);
							   
		for (int i = 0; i < labels.length; i++){			
			int index = ((Label)labels[i]).getText().trim().indexOf("The profiling set about to be removed is applied in more then one configurations");
			
			if(index >= 0){
				doesWarningExist = true;
				break;
			}
		}
		assertTrue(doesWarningExist);
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyProfilingSetRemoveWarning");
	}

	/**
	*  TestLaunchLocalDetached
	*  The purpose of this test case is to launch a local external Java application
	*  and attach/detach from the agent.
	*  
	*  The steps are:
	*  1)Select Profiling Button > Profile ...
	*  2) Select the launch configuration created in the CreateLaunchConfiguration Test Suite
	*  3) Select Profile
	*  4) Select the Agent and Select Detach
	*  5) Verify that the agent is detached
	*  6) Terminate the Profiling
	*  
	*  This method performs the verification described in Step 5) above
	* <b>Purpose:</b> Perform the verification in step #7
	* @throws Exception
	*/
	public void verifyDetach(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyDetach");
		verifyAgentStatus(arg0, "detached");					
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyDetach");
	}

	
	
	private void verifyAgentStatus(org.eclipse.ui.IViewPart arg0, String status)
	{
		boolean found = false;
		Composite profileMonitor = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull ("The profiling monitor selected is null", profileMonitor);		
		VerifyHookUtil.widgetDump(profileMonitor);
		Tree tree = (Tree)VerifyHookUtil.findControl(profileMonitor, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull ("The tree in this view is null",tree);	
		TreeItem[] treeItemSelected  = tree.getSelection();	
    * <li>Check to ensure that the profiling set for the involved launch configurations in step 3 updated accordingly.</li>   
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #7
	* @throws Exception
	*/		
	public void verifyProfilingSetRemoveWarningYes2(org.eclipse.swt.widgets.Shell arg0)
	throws Exception
	{	
		boolean foundSet = false;
		
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyProfilingSetRemoveWarningYes2");			
		
		Control tables[] = VerifyHookUtil.findAllControl(arg0, VerifyHookUtil.TABLE_CONTROL_TYPE, null);
		TableItem[] tableItemsSelected = null;
		
		for(int i = 0; i < tables.length; i++){            
			tableItemsSelected = ((Table)tables[i]).getSelection();			
			
		for(int i = 0; i < treeItemSelected.length; i++)
		{
			if (treeItemSelected[i].getText().indexOf(status) >= 0){
				found = true;
				
			    break;
			}
		}	
		assertTrue( found);
		assertFalse(foundSet);		
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyProfilingSetRemoveWarningYes2");
	}
	
	/**
	*  
	* Meant to be a follow up to ensure that the agent was detached before we started collecting data
	* Need to ensure that the number of collected instances is zero in this view
	* 
	* @param arg0, the View part selected in the View
	*/
	public void verifyNoCollectedInstances(org.eclipse.ui.IViewPart arg0)
    * <li>Click <b>Remove</b> button.</li>   
    * <li>A warning dialog should show up with an appropriate message.</li>   
    * <li>Click <b>Yes</b></li> 
    * <li>Check to ensure that the profiling set for the involved launch configurations in step 3 updated accordingly.</li>   
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #7
	* @throws Exception
	*/		
	public void verifyProfilingSetRemoveWarningYes3(org.eclipse.swt.widgets.Shell arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyProfilingSetRemoveWarningYes3");			
     	verifySelectedTreeItem(arg0, "RemovingSetWarningYes2");
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyProfilingSetRemoveWarningYes3"); 
	}		
	
	/**
	* Verify profiling agent detached status.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Click on <b>Profile</b> button from the tool bar.</li>
    * <li>Double click on <b>External Java Application</b>.</li>
    * <li>In the <b>Main</b> tab, browse for a class name, and then click <b>Apply</b> button.</li>    
    * <li>Click <b>Profile</b> button.</li>   
    * <li>Right click on the agent, and select <b>Detach from Agent</b>.</li>	   
    * <li>Verify agent is detached.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #6
	* @throws Exception
	*/		
	public void verifyLocalDetached(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		 Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLocalDetached");
		 verifyAgentStatus(arg0, "detached");					
		 Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalDetached");
	}	
	
	/**
	* Verify profiling agent paused status.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Click on <b>Profile</b> button from the tool bar.</li>
    * <li>Double click on <b>External Java Application</b>.</li>
    * <li>In the <b>Main</b> tab, browse for a class name, and then click <b>Apply</b> button.</li>    
    * <li>Click <b>Profile</b> button.</li>   
    * <li>Right click on the agent, and select <b>Pause</b>.</li>	   
    * <li>Verify agent is paused.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #6
	* @throws Exception
	*/		
	public void verifyLocalPaused(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyNoCollectedInstances");	
		 verifyAgentStatus(arg0, "attached");					
		 Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalPaused");
	}	
	
	/**
	* Verify profiling agent paused status.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Click on <b>Profile</b> button from the tool bar.</li>
    * <li>Double click on <b>External Java Application</b>.</li>
    * <li>In the <b>Main</b> tab, browse for a class name, and then click <b>Apply</b> button.</li>    
    * <li>Click <b>Profile</b> button.</li>       *    
    * <li>Verify agent is monitoring.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/		
	public void verifyLocalMonitoring(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		 Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLocalMonitoring");
		 verifyAgentStatus(arg0, "monitoring");					
		 Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalMonitoring");
	}	

	/**
	* Verify relaunch from the profile dropdown menu on the toolbar.
	* <p>
	* <b>Testing Steps:</b>
	* <ol>
	* <li>Click on <b>Profile</b> button from the tool bar.</li>
    * <li>Double click on <b>External Java Application</b>.</li>
    * <li>In the <b>Main</b> tab, browse for a class name, and then click <b>Apply</b> button.</li>    
    * <li>Click <b>Profile</b> button.</li>       *    
    * <li>The application should be profiled.</li> 
    * <li>Click on the profile drop down button on the menu bar.</li> 
    * <li>Select the configuration that corresponds to the last launched class (e.g. HelloWorld)</li> 
    * <li>Verify the java process is relaunched and traced.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #8
	* @throws Exception
	*/		
	public void verifyDropDownRelaunch(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
        Logger.getInstance().logMessage(Logger.INFO, "Entering verifyDropDownRelaunch");	
		
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		verifyCollInstances(tree, treeItems, "StartStop", 0);
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyNoCollectedInstances");	
	}
	
	

	/**
	*  verifyCollInstances method to verify the number of collected instances in the Memory Statistics View
	*  and it is meant to show that when the agent is detached, no instances are collected by the profiler
	*  
	* @param tree, the selected tree in the view
	* @param treeItems, an array containing the tree items of tree
	* @param app, the name of application we are profiling
	* @param totalExpected, the number of collected instances we are expecting for app
    * <li>The application should be profiled.</li> 
    * <li>Click on the <b>Profile</b> button on the tool bar.</li> 
    * <li>Verify the java process is relaunched and traced.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #7
	* @throws Exception
	*/
	private void verifyCollInstances(Tree tree, TreeItem[] treeItems, String app, int totalExpected)
	throws Exception
	{
		int collectedInstancesClmnIndex = getTreeColumnIndex(tree, "Collected");
		int appItemIndex = getTreeItemIndex(treeItems, app);		
		int appCollInst = 0;
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		verifyAppInstances(tree, treeItems, "HelloWorld", 1, 1);
		
		for(int i = 0; i < treeItems.length; i++)
		{
			if( i == appItemIndex ){				
				appCollInst = Integer.parseInt((String)treeItems[i].getText(collectedInstancesClmnIndex));
			}		
		}	
		/* verify the Collected Instances of the given application */
		assertTrue(appCollInst == totalExpected);
	}

	/**
	 * A private helper method meant to return the index of a Tree Item given a list of all the
	 * TreeItems and the String (text) we are looking for.
	 * 
	 * @param items, the array of TreeItems
	 * @param item, the String text of the item we are looking for
	 * @return the index of the treeItem we are looking for
	 */
	private int getTreeItemIndex(TreeItem[] items, String item)
    * <li>Verify the java process is relaunched and traced.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #5
	* @throws Exception
	*/		
	public void verifyProfileLastLaunchedRelaunch(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		int index = -1;		
			for(int i = 0; i < items.length; i++)
			{
				if(items[i].getText().trim().equals(item.trim()))
				{
					index = i;
					break;
				}
			}
		return index;	
	}




	
	/**
	 * A private helper method meant to  return the index of a column in the
	 *  Statistics view, given the Tree and the Column's header as a String
	 *  
	 * @param tree A Tree of all the columns
	 * @param column the String representing the column header we are looking for
	 * @return the index of the header
	 */
	private int getTreeColumnIndex(Tree tree, String column)
    * <li>Go to the <b>Limits</b> tab, set the number of method invocations to limit.</li>    
    * <li>Click <b>Profile</b> button.</li>   
    * <li>Verify no new data is received after the specified method invocation times.</li> 
    * </ol>
	* <p>
	* <b>Purpose:</b> Perform the verification in step #7
	* @throws Exception
	*/				  
	public void verifyLimitsCalls(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		int index = -1;
		TreeColumn[] columns = tree.getColumns();
		for(int i = 0; i < columns.length; i++)
		{
			if(columns[i].getText().trim().equals(column.trim()))
			{
				index = i;
				break;
			}
		}
		return index;		
	}

	/**
	 * TestLaunchAndAttach
	 * Note: The methods below are used to verify various relaunch scenarios including:
	 * 1- Profile last Launched
	 * 2- Using the Profile Button to Relaunch
	 * 3- Using the Profile Drop Down Menu to Relaunch
	 * 
	 *  This test is meant to launch an external local Java applaictaion, attach
	 *  and profile and then verify the results using the two verification hooks below.
	 *  The steps to execute this test manually are:
	 *  1) Select Profile> Profile..
	 *  2) Double Click External Java Application
	 *  3) Select the HelloWorld application avaiblae in the Resources folder
	 *  4) Select Profile
	 *  5) After termination, open the Memory Statistics View
	 *  6) Verify that the application was profiled and appropriate data was collected
	 */
	/**
	 * A Method to ensure that the application in question ahs terminated profiling
	 * In order to verify this we check teh status. Meant to ensure we do not open the
	 * Statistics views too early
	 * @param arg0, the ViewPart Selected (normally one of the statistics views in the Profiling and Logging Perspective)
	 * @throws Exception
*/
	public void verifyMonitoringCollecting(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyMonitoringCollecting");
		verifyAgentStatus(arg0, "terminated");					
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyMonitoringCollecting");
	}

	/**
	 * A Method to verify the Class Level instance information in the Memory Statistics View
	 *  after an application has terminated its profiling.
	 *  
	 * @param arg0, the View Part selected in the View
	 * @throws Exception
	 */
	public void verifyClassLevel(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyClassLevel");	
		
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		assertTrue(" The Tree Selected contains no items", treeItems.length > 0);
		/* call to verify the instances collected in this view for this particualr app*/
		verifyAppInstances(tree, treeItems, "HelloWorld", 1, 1);
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting  verifyClassLevel");	
	
	private void verifyAgentStatus(org.eclipse.ui.IViewPart arg0, String status){
		boolean found = false;
		Composite profileMonitor = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (profileMonitor);		
		VerifyHookUtil.widgetDump(profileMonitor);
		 
		Tree tree = (Tree)VerifyHookUtil.findControl(profileMonitor, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		 
		TreeItem[] treeItemSelected  = tree.getSelection();	
			
		for(int i = 0; i < treeItemSelected.length; i++){
			if (treeItemSelected[i].getText().indexOf(status) >= 0){
				found = true;
			    break;
			}
		}	
		assertTrue(found);
	}
	
	private void verifySelectedTreeItem(org.eclipse.swt.widgets.Shell arg0, String label){
		Control trees[] = VerifyHookUtil.findAllControl(arg0, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		TreeItem[] treeItemsSelected = null;
		boolean itemFound = false;
		
		for (int i = 0; i < trees.length; i++){
			treeItemsSelected = ((Tree)trees[i]).getSelection();
			 
			for (int j = 0; j < treeItemsSelected.length; j ++){
				if(treeItemsSelected[j].getText().trim().equals(label)){
					itemFound = true;
					break;
				}
			}			
		}				
		assertTrue(itemFound);			
	}

	/**
	 * A private helper method intended to verify the numebr of instances listed in the
	 * Class level view of the Memory Statistics view for an application.
	 * It takes in an expected number of total and live instances and compares them
	 * with the numbers reproted in the view, making sure they are equal
	 * 
	 * @param tree, the selected tree in the View
	 * @param treeItems, an arary of the items in tree
	 * @param app, the name as a String of the application we are profiling
	 * @param totalExpected, the total number of instances expected
	 * @param activeExpected, the total number of live instances expected
	 */
	private void verifyAppInstances(Tree tree, TreeItem[] treeItems, String app, int totalExpected, int activeExpected)
	{
	
		// in order to make the test case more flexible so it can be run on different machines, we allow a threshold of error for the 
		// hard-coded values for number of instances in StartStop
		
		int totalInstancesClmnIndex = getTreeColumnIndex(tree, "Total Instances");
		int liveInstancesClmnIndex = getTreeColumnIndex(tree, "Live Instances");	
		
		int appItemIndex = getTreeItemIndex(treeItems, app);		
		
		int appTotalInst = 0;
		int appLiveInst = 0;
	
		for(int i = 0; i < treeItems.length; i++)
		{
			if( i == appItemIndex )
			{				
				appTotalInst = Integer.parseInt((String)treeItems[i].getText(totalInstancesClmnIndex));
				appLiveInst = Integer.parseInt((String)treeItems[i].getText(liveInstancesClmnIndex));
				
			}		
		}	
		if (totalExpected > 5000)
		{
			// then we know we are in the StartStop case so we allow a threshold to make the tes more flexible
			assertTrue("<EXPECTED TOTAL INSTANCES ARE TOO FAR FROM THE ACTUAL VALUES>",(appTotalInst <= totalExpected + 500) && (appTotalInst >= totalExpected-500) );
			assertTrue("<EXPECTED ACTIVE INSTANCES ARE TOO FAR FROM THE ACTUAL VALUES>",(appLiveInst <= activeExpected + 500) && (appLiveInst >= activeExpected-500) );
		}
		else
		{		/* verify the Total Instances and Live Instances of App */
			assertTrue("<EXPECTED TOTAL INSTANCES>" + totalExpected + "<ACTUAL TOTAL INSTANCES> " + appTotalInst,appTotalInst == totalExpected);
			assertTrue("<EXPECTED ACTIVE INSTANCES>" + activeExpected + "<ACTUAL ACTIVE INSTANCES> " + appLiveInst, appLiveInst == activeExpected);
			if(items[i].getText().trim().equals(item.trim())){
				index = i;
				break;
			}
		}
		return index;	
	}
	
	private int[] getTreeItemIndexes(TreeItem[] items, String[] names){		
		
		int[] indexes = new int[names.length];
		
		for(int i = 0; i < names.length; i++){
			indexes[i] = getTreeItemIndex(items, names[i]);
		}						
		return indexes;	
	}

	

	/**
	* TestProfilingLimitCalls
	*  
	*  This test case is designed to test the feature allowing a user to
	*  limit the data collected and stop profilign after a certain number
	*  of method invocations. The steps are as follows:
	*  
	*  1) Select Profile> Profile...
	*  2) Double Click on External Java Application
	*  3) Name it Limits
	*  4) Under the Main Tab point to the Limits.class in the Resource Folder
	*  5) Select only Execution Time Analysis under Monitor
	*  6) Select Java Profiling Options
	*  7) Select Edit Options
	*  8) Next
	*  9) Check next to 'stop after a certain number of invocations'
	*  10) Enter '7' in the field
	*  11) Finish> Profile
	*  12) Verify that once profilign has terminated, you see 7 calls in total in
	*  the package level view.
	*  
	* @param arg0, the view part selected in the view
	* @throws Exception
	*/
	public void verifyProfilingLimitsCalls(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyProfilingLimitsCalls");
		
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		assertTrue(" The selected Tree has no treeItems", treeItems.length >0);
		verifyCallsDetails(tree, treeItems, new String[]{"(default package)"}, 7, true);			
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLimitsCalls");
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyProfilingLimitsCalls");
	}

	/**
	 *  A private helper method which verifies the information in a Statistics View
	 *  of the Profiling and Logging Perspective.
	 *  It takes in the number of calls we are expecting and compares them to what is
	 *  actually there.
	 *  
	 * @param tree
	 * @param treeItems
	 * @param names
	 * @param callTimes
	 * @param equal
	 */
	
	private void verifyCallsDetails(Tree tree, TreeItem[] treeItems, String[] names, int callTimes, boolean equal)
	{
		int callsClmnIndex = getTreeColumnIndex(tree, "Calls");
		int[] indexes = getTreeItemIndexes(treeItems, names); 
		
		ArrayList calls = new ArrayList();
			
		for(int i = 0; i < treeItems.length; i++)
		{
			if(isIn(i, indexes))
			{					
				calls.add(treeItems[i].getText(callsClmnIndex));			
			}			
		}
		
		/* This section verifies following requirments: calls >= callTimes */
		Object[] callsObj = calls.toArray();
		assertTrue(" The calls Column has not been properly selected",callsObj.length >0);
		
		for(int j = 0; j < callsObj.length; j++)
		{	
			if(equal)
			{
				assertTrue("<ACTUAL NUMBER OF INVOCATIONS> " + (String)callsObj[j] + " <EXPECTED NUMBER OF INVOCATIONS> " + callTimes,Integer.parseInt((String)callsObj[j]) == callTimes);
			}else
			{
				assertTrue(Integer.parseInt((String)callsObj[j]) >= callTimes);
			}			
		}
	}

	/**
	 *  A private helper method which returns a boolean value representing whether
	 *  or not a given int is in a given array of numbers.
	 *  
	 * @param index The int we are looking for
	 * @param nums The array of ints we are looking in
	 * @return True if index IsIn nums, False otherwise.
	 */
	private boolean isIn(int index, int[] nums)
	{
		for(int i = 0; i < nums.length; i++)
		{
			if(index == nums[i])
			{
				return true;
			}
		}
		return false;
}
	
	private int[] getTreeItemIndexes(TreeItem[] items, String[] names){		
		
		int[] indexes = new int[names.length];
		
		for(int i = 0; i < names.length; i++){
			indexes[i] = getTreeItemIndex(items, names[i]);
		}						
		return indexes;	
	}

	/**
	 * TestProfilingLimitsTime
	 *  
	 *  This test case is designed to test the feature allowing a user to
	 *  limit the data collected and stop profiling after a certain number
	 *  of seconds. The steps are as follows:
	 *  
	 *  1) Select Profile> Profile...
	 *  2) Double Click on External Java Application
	 *  3) Name it Limits
	 *  4) Under the Main Tab point to the Limits.class in the Resource Folder
	 *  5) Select only Execution Time Analysis under Monitor
	 *  6) Select Java Profiling Options
	 *  7) Select Edit Options
	 *  8) Next
	 *  9) Check next to 'stop profiling after a specified amount of time'
	 *  10) Enter '5' in the field (or accept default if its 5)
	 *  11) Finish> Profile
	 *  12) Verify that once profilign has terminated, you do not see the MethodB invocatoinas called since it takes longer than 5 seconds to 
	 *      be called.
	 *      
	 * @param arg0, the ViewPart selected in the View 
	 * @throws Exception
	 */
	
	public void verifyProfilingLimitsTime(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyProfilingLimitsTime");
	
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();	
		assertTrue("The selected Tree has no treeItems", treeItems.length >0);
		assertTrue("methodB is present even though it wasn't expected to be incldued as part of the trace", getTreeItemIndex(treeItems, "methodB() void") == -1); 
					
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyProfilingLimitsTime");
	}

	/**
	* 
	*  A test to verify that when Monitoring is paused, there is no data being collected
	*  and when monitoring is resumed, data is collected again from the application.
	*  
	*  This method does so by verifying that the status of teh agent is set to paused when the
	*  Pause option is selected. Verification of the data collection being paused is accomplished in otehr methods
	*   
	* @throws Exception
	*/
	public void verifyLocalPaused(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLocalPaused");
		verifyAgentStatus(arg0, "attached");					
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalPaused");
	}

	/**
	* TestLocalPauseAndResume
	*  
	*  This verification method tests to ensure that the data collection is also paused
	*  when monitoring has been paused.
	*  
	*  1) Select Profile> Profile...
	*  2) Double Click on External Java Application
	*  3) Name it StartStop
	*  4) Under the Main Tab point to the Limits.class in the Resource Folder
	*  5) Select only Memory Statistics under Monitor
	*  6) Sleect Profile
	*  7) Once profiling has started, press  Enter once in the Console View
	*  8) Select the AGent and Right Click > Pause
	*  9) Verify that the status changes to paused
	*  10) Open the Memory Statistic View and check the numebr of instances (total and active)
	*  11) Resume Monitoring
	*  12) Press Enter againin the console View
	*  13) Open the Mem Stats again and ensure taht monitoring resumed and taht tehre are more instances
	*   (active and total) than there were in step 10.
	* 
	* verifyLocalInstancesPaused performs the verification is Step 10)
	* 
	* @arg0 The viewPart selected in the View
	* @throws Exception
	*/
	public void verifyLocalInstancesPaused(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLocalInstancesPaused");
		
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		assertTrue(" The selected Tree has no treeItems", treeItems.length >0);
		verifyAppInstances(tree, treeItems, "(default package)", 5163,5163);
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalInstancesPaused");
	}

	/**
	* TestLocalPauseAndResume
	*  
	*  This method is meant to verify that after a pause ahs been resumed, the agent's status
	*  read's 'Monitoring' again. The verification of data collection is doen in other methods
	* 
	* @throws Exception
	*/
	public void verifyLocalMonitoring(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		 Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLocalMonitoring");
		 verifyAgentStatus(arg0, "monitoring");					
		 Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalMonitoring");
	}

	/**
	* This method performs the verification in Step 13) of verifyLocalPauseAndResume
	* It is meant to show that the data collection resumes correctly after a pause and resume
	* of the agent.
	*
	* @throws Exception
	*/
	public void verifyLocalInstancesMonitoring(org.eclipse.ui.IViewPart arg0)
	throws Exception
	{
		Logger.getInstance().logMessage(Logger.INFO, "Entering verifyLocalInstancesMonitoring");
		
		Composite memoryStatisticsView = VerifyHookUtil.getWorkbenchPartControl(arg0);
		assertNotNull (memoryStatisticsView);				
		Tree tree = (Tree)VerifyHookUtil.findControl(memoryStatisticsView, VerifyHookUtil.TREE_CONTROL_TYPE, null);
		assertNotNull (tree);	
		TreeItem[] treeItems = tree.getItems();
		assertTrue(" The selected Tree has no treeItems", treeItems.length >0);
		verifyAppInstances(tree, treeItems, "(default package)", 5204,5204);			
		
		Logger.getInstance().logMessage(Logger.INFO, "Exiting verifyLocalInstancesMonitoring");
	}



}




import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Date;

/**********************************************************************
 * Copyright (c) 2004 Hyades project.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors: 
 * IBM - Initial API and implementation
 **********************************************************************/

/**
 * StartStop test class to verify the object reference using UI. 
 * 
 * 
 * @author Praful Rajawat
 * @author Paul E. Slauenwhite
 * @version February 10, 2005
 */
public class StartStop {

    public static void main(String[] args) {

        StartStop aStartStop = new StartStop();

        Date strtDate = new Date();
        
        System.out.println("Start timestamp = " + strtDate);

        //Read standard in, just as a way of pausing the exit:
        try {
            System.out.println("\nStop monitoring or detach and then press the Enter key.");
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            String line = in.readLine();
        } 
        catch (Exception e) {}

        aStartStop.methodA();

        //Read standard in, just as a way of pausing the exit:
        try {
            System.out.println("\nStart monitoring or attach and then press the Enter key.");
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            String line = in.readLine();
        } 
        catch (Exception e) {}

        aStartStop.methodB();

        Date endDate = new Date();
        
        System.out.println("End timestamp = " + endDate);
        System.out.println("Start time = " + strtDate.getTime());
        System.out.println("End   time = " + endDate.getTime());
        System.out.println("elapsed time = " + (endDate.getTime() - strtDate.getTime()) + " msec");
    }

    public void methodA() {
        
        Date curdate = new Date();
        int count = 1;
        
        for (int counter = 0; counter < 10000; counter++) {
            count = (counter * 3 + count);
        }
        
        System.out.println("\nmethodA - Current timestamp = " + curdate);
    }

    public void methodB() {

        Date curdate = new Date();
        int count = 1;
        
        for (int counter = 0; counter < 10000; counter++) {
            count = (counter * 3 + count);
        }
        
        System.out.println("methodB - Current timestamp = " + curdate + "\n");
    }
}

Lines 1-4 Link Here

(-).settings/org.eclipse.core.resources.prefs (-1 / +3 lines)
1	#Wed Sep 20 14:48:26 EDT 2006	1	#Mon Dec 04 09:37:59 EST 2006
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
		3	encoding//src/org/eclipse/hyades/use/cases/auto/profiling/logging/PlatformUIProfilingPerspectiveLaunchPart4.java=UTF-8
		4	encoding//src/org/eclipse/hyades/use/cases/auto/profiling/logging/PlatformUIProfilingPerspectiveLaunchPart5.java=UTF-8
3	encoding//src/org/eclipse/hyades/use/cases/auto/profiling/logging/PlatformUIProfilingPerspectiveLaunchPart6.java=UTF-8	5	encoding//src/org/eclipse/hyades/use/cases/auto/profiling/logging/PlatformUIProfilingPerspectiveLaunchPart6.java=UTF-8
4	encoding//src/org/eclipse/hyades/use/cases/auto/profiling/logging/PlatformUIProfilingPerspectiveLaunchPart7.java=UTF-8	6	encoding//src/org/eclipse/hyades/use/cases/auto/profiling/logging/PlatformUIProfilingPerspectiveLaunchPart7.java=UTF-8





public class HelloWorld {
	
		public static void main(String[] args) 
		{
			HelloWorld hellWorld = new HelloWorld();
			hellWorld.rootMethod1();
			hellWorld.rootMethod2();
		}
		
		public void rootMethod1()
		{
			System.out.println("rootMethod1 called");
			childMethod1();
		}
		
		public void rootMethod2()
		{
			System.out.println("rootMethod2 called");
		}
			
		public void childMethod1()
		{
			System.out.println("childMethod1 called");
		}

	}



Added Link Here

(-)gui/Profiling_and_Logging/Launch/Platform.UI.ProfilingPerspective.Launch.Part4.Resources/Platform.UI.ProfilingPerspective.Launch.Part4.datapool (+4 lines)
1	PKwF5ResourceContentsT]oÚ0}´ÿ`ùaoóI`¡8DëÄ$Zmo¸`É3Û@ûï{ùH(TPöæÜë{Î¹çÞ8¹}.%ZqmªØs\x«BTó~\|È¾Æøöæó§ª²TÕYV+%ûétÒÑs)ú-¿?ÐÊô!>Àkë>!ëõÚQåÜQzN~ÿ¼k®À]ç¹µáÛÅ+¸!¥¸4$ßVb_åF¢à±?Å~Ã(¢]:
2	ÓÔsÝÌ?ÆYèyé#@Éµ¨íVkÛ?Uh¡d?VLöWrFvÁÑT2çÒy¼s¦Z= ÎL¡ÙçV¬¸3aË*_8S¦mYn,2Ka¹QÅJ>ÀÿÁjþo)VLÂ 8ÌÐs¡;ÿÐÝr\|Rîí`Xó\éÂì?!?s)
3	´-P÷EÚoÐ®¼YÐ3³ªÞIÅCgÕrÍwH¨_JËâ,OÐÎ(ôi{a×¥A8³ºQæ?¯æRXs#íR¿G{ÝN7ö½ºèz>pÐè#!o-LÈûIíÍjÎ`Êfçµn5¼P¼Ý¬{ad_jÈÌ¬ð¡?cüÍÝãQÖÿ`+6¬ëëá?ôu/7ãy°.$ä±w\x ÿ
4	PK¹$ä¾õàPKwF5¹$ä¾õàResourceContentsPK>3

Added Link Here

(-)src/Hello_World.java (+4 lines)
1
2	public class Hello_World {
3
4	}

Added Link Here

(-)gui/Profiling_and_Logging/Launch/Platform.UI.ProfilingPerspective.Launch.Part5.Resources/Platform.UI.ProfilingPerspective.Launch.Part5.datapool (+6 lines)
1	PK\?5ResourceContents?SÉnÂ0½Wê?X>ôFLÒD*Q)Eêr,9qj¥ß %e{æ½7oÆö\ SË"À¶ÕÄLyxööÜèâAÿþÎÉ<ÅGD
2	-¥½(Ô{´ÉyoOáT@ZèÜxaLÙ#d½^[2Ï,©2òþúR§Ð¥³DðR³-dñMS¦I.S&4I¶(îPaÄÓ?]¯õzÍ¦ç?á°EÃN»Ûiv½Ðµí(Ä¨ 9p,¨K[³+VrÎø?ÁBÉÃWÌÐe,¬*ÓÂà!}-ù
3	è ª5Ó×$?SÉñ Üþ¥bÅ©R½;ÂEÂÐ{æiÂ
4	STôTe6ªVg»ºU?ÔQÅé§`«z?ö_#È
5	rSö§F7Ë8?qäÝJÆ;ñÉ¡K7ó7P?t
6	¸Ö^{o¤¨úw*ÇþwSªLcd¾KØO?WðWòuÆ3«;Æ}Ó.ÒúäÐaõ±ÈñPK\|æKJ?¡PK\?5\|æKJ?¡ResourceContentsPK>Ë

Return to bug 165936

Removed Link Here

(-)gui/Profiling_and_Logging/Common/Common.Resources/StartStop.java (-85 lines)
1	import java.io.BufferedReader;
2	import java.io.InputStreamReader;
3	import java.util.Date;
4
5	/**********************************************************************
6	* Copyright (c) 2004 Hyades project.
7	* All rights reserved. This program and the accompanying materials
8	* are made available under the terms of the Common Public License v1.0
9	* which accompanies this distribution, and is available at
10	* http://www.eclipse.org/legal/cpl-v10.html
11	*
12	* Contributors:
13	* IBM - Initial API and implementation
14	**********************************************************************/
15
16	/**
17	* StartStop test class to verify the object reference using UI.
18	*
19	*
20	* @author Praful Rajawat
21	* @author Paul E. Slauenwhite
22	* @version February 10, 2005
23	*/
24	public class StartStop {
25
26	public static void main(String[] args) {
27
28	StartStop aStartStop = new StartStop();
29
30	Date strtDate = new Date();
31
32	System.out.println("Start timestamp = " + strtDate);
33
34	//Read standard in, just as a way of pausing the exit:
35	try {
36	System.out.println("\nStop monitoring or detach and then press the Enter key.");
37	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
38	String line = in.readLine();
39	}
40	catch (Exception e) {}
41
42	aStartStop.methodA();
43
44	//Read standard in, just as a way of pausing the exit:
45	try {
46	System.out.println("\nStart monitoring or attach and then press the Enter key.");
47	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
48	String line = in.readLine();
49	}
50	catch (Exception e) {}
51
52	aStartStop.methodB();
53
54	Date endDate = new Date();
55
56	System.out.println("End timestamp = " + endDate);
57	System.out.println("Start time = " + strtDate.getTime());
58	System.out.println("End time = " + endDate.getTime());
59	System.out.println("elapsed time = " + (endDate.getTime() - strtDate.getTime()) + " msec");
60	}
61
62	public void methodA() {
63
64	Date curdate = new Date();
65	int count = 1;
66
67	for (int counter = 0; counter < 10000; counter++) {
68	count = (counter * 3 + count);
69	}
70
71	System.out.println("\nmethodA - Current timestamp = " + curdate);
72	}
73
74	public void methodB() {
75
76	Date curdate = new Date();
77	int count = 1;
78
79	for (int counter = 0; counter < 10000; counter++) {
80	count = (counter * 3 + count);
81	}
82
83	System.out.println("methodB - Current timestamp = " + curdate + "\n");
84	}
85	}

Added Link Here

(-)src/HelloWorld.java (+29 lines)
1
2	public class HelloWorld {
3
4	public static void main(String[] args)
5	{
6	HelloWorld hellWorld = new HelloWorld();
7	hellWorld.rootMethod1();
8	hellWorld.rootMethod2();
9	}
10
11	public void rootMethod1()
12	{
13	System.out.println("rootMethod1 called");
14	childMethod1();
15	}
16
17	public void rootMethod2()
18	{
19	System.out.println("rootMethod2 called");
20	}
21
22	public void childMethod1()
23	{
24	System.out.println("childMethod1 called");
25	}
26
27	}
28
29