1 /*

     2  * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:  Definitions for the class TreeHelper

    15  *

    16  */

    17 

    18 package com.nokia.s60tools.analyzetool.ui;

    19 

    20 import java.util.AbstractList;

    21 import java.util.Hashtable;

    22 import java.util.Iterator;

    23 

    24 import org.eclipse.jface.preference.IPreferenceStore;

    25 

    26 import com.nokia.s60tools.analyzetool.engine.AnalysisItem;

    27 import com.nokia.s60tools.analyzetool.engine.CallstackItem;

    28 import com.nokia.s60tools.analyzetool.engine.MMPInfo;

    29 import com.nokia.s60tools.analyzetool.engine.RunResults;

    30 import com.nokia.s60tools.analyzetool.engine.Subtest;

    31 import com.nokia.s60tools.analyzetool.global.Constants;

    32 import com.nokia.s60tools.analyzetool.global.Util;

    33 

    34 /**

    35  * Class to create Tree model for the AnalyzeTool view.

    36  *

    37  * @author kihe

    38  *

    39  */

    40 public class TreeHelper {

    41 

    42 

    43 	/** Last active memory leak tree item. */

    44 	private TreeObject activeTreeItem;

    45 

    46 	/** Last selected tree item. */

    47 	private final Object lastSelectedObject;

    48 

    49 	/** Contains module leak info. */

    50 	private final java.util.Hashtable<String, Integer> moduleLeaks;

    51 

    52 	/** Used AnalyzeTool preference store */

    53 	private final IPreferenceStore store;

    54 

    55 	/** Contains already checked modules states */

    56 	private final Hashtable<String, Boolean> checkedModules;

    57 

    58 	/** Contains information which modules are part of the project */

    59 	private final Hashtable<String, Boolean> projectModules;

    60 

    61 	/**

    62 	 * Constructor.

    63 	 *

    64 	 * @param selectedObject

    65 	 *            Last selected tree item

    66 	 *

    67 	 * @param storeRef AnalyzeTool preference store reference

    68 	 */

    69 	public TreeHelper(final Object selectedObject,

    70 			final IPreferenceStore storeRef) {

    71 		lastSelectedObject = selectedObject;

    72 		moduleLeaks = new java.util.Hashtable<String, Integer>();

    73 		store = storeRef;

    74 		checkedModules = new Hashtable<String, Boolean>();

    75 		projectModules = new Hashtable<String, Boolean>();

    76 	}

    77 

    78 	/**

    79 	 * Compares two different TreeObject.

    80 	 *

    81 	 * @param obj1

    82 	 *            Actual

    83 	 * @param obj2

    84 	 *            New object

    85 	 * @return True if objects equals otherwise false

    86 	 */

    87 	public final boolean compareItems(final Object obj1, final Object obj2) {

    88 		boolean found = false;

    89 

    90 		if (obj1 == null || obj2 == null) {

    91 			return false;

    92 		}

    93 

    94 		TreeObject tree1 = (TreeObject) obj1;

    95 		TreeObject tree2 = (TreeObject) obj2;

    96 

    97 		if (tree1.getMemLeakID() == tree2.getMemLeakID()

    98 				&& tree1.getRunID() == tree2.getRunID()

    99 				&& tree1.getName().equals(tree2.getName())

   100 				&& tree1.getSubtestID() == tree2.getSubtestID()) {

   101 			activeTreeItem = (TreeObject) obj1;

   102 			found = true;

   103 		}

   104 		return found;

   105 	}

   106 

   107 	/**

   108 	 * Creates tree node for analysis items.

   109 	 *

   110 	 * @param oneRunTree

   111 	 *            Current item parent tree node

   112 	 * @param items

   113 	 *            Analysis items

   114 	 * @param runID

   115 	 *            Current run id

   116 	 * @param isSubtest

   117 	 *            Is this element subtest

   118 	 * @param subTestID

   119 	 *            Subtest ID

   120 	 * @param modules Selected project target modules

   121 	 * @return How many items created

   122 	 */

   123 	public final int createItemResults(final TreeParent oneRunTree,

   124 			final AbstractList<AnalysisItem> items, final int runID,

   125 			final boolean isSubtest, final int subTestID, AbstractList<MMPInfo> modules) {

   126 		boolean thereAreItemsDisplayed = false;

   127 		moduleLeaks.clear();

   128 

   129 		int displayed = 0;

   130 		// thru actual memory leaks

   131 		Iterator<AnalysisItem> iterItem = items.iterator();

   132 		while (iterItem.hasNext()) {

   133 			// get one analysis file

   134 			AnalysisItem oneItem = iterItem.next();

   135 

   136 			if (getActiveDetailLevel().equals(Constants.REPORT_EVERY)

   137 					|| oneItem.containValidCallstack()) {

   138 				displayed++;

   139 				char space = ' ';

   140 				StringBuffer leakString = new StringBuffer(64);

   141 				leakString.append(Constants.ITEM_TREE_MEM_LEAKS);

   142 				leakString.append(oneItem.getID());

   143 				leakString.append(" (");

   144 				leakString.append(oneItem.getLeakSize());

   145 				leakString.append(" bytes) (");

   146 				leakString.append(oneItem.getMemoryAddress());

   147 				leakString.append(") ");

   148 				leakString.append(oneItem.getMemoryLeakTime());

   149 				leakString.append(space);

   150 				leakString.append(oneItem.getModuleName());

   151 

   152 				TreeObject oneLeak = new TreeObject();

   153 				if (!modules.isEmpty()) {

   154 					oneLeak.setBuild(checkItemBuildState(modules, oneItem.getModuleName()));

   155 					oneLeak.setBelongs(checkProjectModules(modules, oneItem.getModuleName()));

   156 				}

   157 

   158 				if (isSubtest) {

   159 					oneLeak.setSubtest(true);

   160 					oneLeak.setSubtestID(subTestID);

   161 				}

   162 				oneLeak.setRunID(runID);

   163 				oneLeak.setMemLeakID(oneItem.getID());

   164 				oneLeak.setName(leakString.toString());

   165 				oneLeak.setModuleName(oneItem.getModuleName());

   166 				oneLeak.setMemAddress(oneItem.getMemoryAddress());

   167 

   168 				oneRunTree.addChild(oneLeak);

   169 				thereAreItemsDisplayed = true;

   170 				updateModuleLeaksInfo(oneItem.getModuleName());

   171 				compareItems(oneLeak, lastSelectedObject);

   172 			}

   173 

   174 		}

   175 

   176 		// if no leaks added to list

   177 		if (!thereAreItemsDisplayed && !items.isEmpty()) {

   178 			TreeObject infoObject = new TreeObject();

   179 			infoObject.setName(Constants.NO_MEM_LEAKS_CURRENT_LEVEL);

   180 			oneRunTree.addChild(infoObject);

   181 		}

   182 		return displayed;

   183 	}

   184 

   185 	/**

   186 	 * Check is module built with AnalyzeTool

   187 	 * @param modules Project modules

   188 	 * @param moduleName Module name

   189 	 * @return True if module is built with AnalyzeTool otherwise false

   190 	 */

   191 	private final boolean checkItemBuildState( AbstractList<MMPInfo> modules, String moduleName)

   192 	{

   193 		if( checkedModules.containsKey(moduleName)) {

   194 			return checkedModules.get(moduleName);

   195 		}

   196 		else if (!modules.isEmpty()) {

   197 			boolean build = Util.chechModuleBuildState(modules, moduleName);

   198 			if( !build ) {

   199 				checkedModules.put(moduleName, build);

   200 			}

   201 			return build;

   202 		}

   203 		return false;

   204 	}

   205 

   206 	/**

   207 	 * Checks is module part of the project

   208 	 * @param modules Project modules

   209 	 * @param moduleName Module name

   210 	 * @return True if module is part of the project otherwise false

   211 	 */

   212 	private final boolean checkProjectModules(AbstractList<MMPInfo> modules, String moduleName)

   213 	{

   214 		if( projectModules.containsKey(moduleName) ) {

   215 			return projectModules.get(moduleName);

   216 		}

   217 		else if( !modules.isEmpty() ) {

   218 			boolean partOfTheProject = Util.isModulePartOfProject(modules,moduleName);

   219 			projectModules.put(moduleName, partOfTheProject);

   220 			return partOfTheProject;

   221 		}

   222 		return false;

   223 	}

   224 

   225 	/**

   226 	 * Creates tree item for run results.

   227 	 *

   228 	 * @param oneRunResults

   229 	 *            One run results

   230 	 * @param modules Selected project target modules

   231 	 * @return Tree item which contains run results

   232 	 */

   233 	public final TreeParent createRunResults(final RunResults oneRunResults, AbstractList<MMPInfo> modules) {

   234 

   235 		// create new run tree

   236 		TreeParent oneRunTree = new TreeParent("");

   237 		oneRunTree.setRunID(oneRunResults.getItemID());

   238 

   239 		// create new handle leak tree

   240 		TreeParent handleSummary = getHandleLeakInfo(oneRunResults

   241 				.getHandleLeaks(), oneRunResults.getItemID(), modules);

   242 		if (handleSummary.hasChildren()) {

   243 			oneRunTree.addChild(handleSummary);

   244 		}

   245 

   246 		// if no memory leaks set "No memory leaks" info

   247 		AbstractList<AnalysisItem> items = oneRunResults.getAnalysisItems();

   248 		if (items.isEmpty()) {

   249 			TreeObject noLeaks = new TreeObject();

   250 			noLeaks.setName(Constants.RUN_NO_LEAKS);

   251 			oneRunTree.addChild(noLeaks);

   252 		}

   253 

   254 		// create item tree and calculate how many of memory leaks are displayed

   255 		int howManyDisplayed = createItemResults(oneRunTree, items,

   256 				oneRunResults.getItemID(), false, 0, modules);

   257 		oneRunTree.setName(getRunTreeTitle(oneRunResults, howManyDisplayed));

   258 

   259 		// module leaks

   260 		TreeParent moduleSummary = getModuleLeakInfo(getCalcModuleLeaksInfo(),

   261 				oneRunResults.getItemID(), modules);

   262 		if (moduleSummary.hasChildren()) {

   263 			oneRunTree.addChild(0, moduleSummary);

   264 		}

   265 

   266 		// get subtests

   267 		AbstractList<Subtest> subtest = oneRunResults.getSubtest();

   268 		createSubtestResults(oneRunTree, subtest, oneRunResults.getItemID(), modules);

   269 

   270 		return oneRunTree;

   271 	}

   272 

   273 	/**

   274 	 * Creates tree node for subtests.

   275 	 *

   276 	 * @param oneRunTree

   277 	 *            Parent tree node

   278 	 * @param subtest

   279 	 *            Subtest information

   280 	 * @param runID

   281 	 *            Current run id

   282 	 * @param modules Selected project target modules

   283 	 */

   284 	public final void createSubtestResults(final TreeParent oneRunTree,

   285 			final AbstractList<Subtest> subtest, final int runID, AbstractList<MMPInfo> modules) {

   286 		// thru subtest

   287 		Iterator<Subtest> iterSubtest = subtest.iterator();

   288 

   289 		// thru subtest

   290 		while (iterSubtest.hasNext()) {

   291 			// get subtest

   292 			Subtest oneSubtest = iterSubtest.next();

   293 

   294 			// create tree item for the subtest

   295 			TreeParent oneSubtestParent = new TreeParent("");

   296 

   297 			// get and calculate how many memory leaks subtest contains

   298 			int howManyDisplayed = createItemResults(oneSubtestParent,

   299 					oneSubtest.getAnalysisItems(), runID, true, oneSubtest

   300 							.getItemID(), modules);

   301 

   302 			// udpate subtest tree title

   303 			oneSubtestParent.setName(getSubtestTreeTitle(oneSubtest,

   304 					howManyDisplayed));

   305 

   306 			if (oneSubtest.getAnalysisItems().isEmpty()) {

   307 				TreeObject noLeaks = new TreeObject();

   308 				noLeaks.setName(Constants.RUN_NO_LEAKS);

   309 				oneSubtestParent.addChild(noLeaks);

   310 			}

   311 

   312 			// if subtest contains handle leaks

   313 			TreeParent handleLeaksInfo = getHandleLeakInfo(oneSubtest

   314 					.getHandleLeaks(), oneSubtest.getItemID(), modules);

   315 			if (handleLeaksInfo.hasChildren()) {

   316 				oneSubtestParent.addChild(handleLeaksInfo);

   317 			}

   318 

   319 			// set subtest module leak info

   320 			TreeParent moduleLeaksInfo = getModuleLeakInfo(

   321 					getCalcModuleLeaksInfo(), oneSubtest.getItemID(), modules);

   322 			if (moduleLeaksInfo.hasChildren()) {

   323 				oneSubtestParent.addChild(0, moduleLeaksInfo);

   324 			}

   325 

   326 			oneRunTree.addChild(oneSubtestParent);

   327 		}

   328 	}

   329 

   330 	/**

   331 	 * Gets active detail level.

   332 	 *

   333 	 * @return Active detail level

   334 	 */

   335 	public final String getActiveDetailLevel() {

   336 		// get active report level

   337 		return store.getString(Constants.REPORT_LEVEL);

   338 	}

   339 

   340 	/**

   341 	 * Returns active item of tree.

   342 	 *

   343 	 * @return Active itemf

   344 	 */

   345 	public final TreeObject getActiveItem() {

   346 		return activeTreeItem;

   347 	}

   348 

   349 	/**

   350 	 * Returns tree item which contains callstack information.

   351 	 *

   352 	 * @param item

   353 	 *            AnalysisItem

   354 	 * @param modules Selected project target modules

   355 	 * @return Tree item

   356 	 */

   357 	public final TreeParent getCallstack(final AnalysisItem item, AbstractList<MMPInfo> modules) {

   358 

   359 		// get active logging mode

   360 		String reportLevel = store.getString(Constants.REPORT_LEVEL);

   361 

   362 		// create tree parent for test runs

   363 		TreeParent testRuns = new TreeParent(Constants.ITEM_TREE_MEM_LEAKS

   364 				+ item.getID() + " " + item.getMemoryLeakTime());

   365 

   366 		// get callstack items

   367 		Iterator<CallstackItem> stackItems = item.getCallstackItems()

   368 				.iterator();

   369 

   370 		// is one know line printed

   371 		boolean printed = false;

   372 

   373 		// thru call stack items

   374 		while (stackItems.hasNext()) {

   375 			// get one callstack item

   376 			CallstackItem oneStackItem = stackItems.next();

   377 

   378 			TreeObject to = new TreeObject();

   379 

   380 			// get function name, memory leak line number and file name

   381 			String functionName = oneStackItem.getFunctionName();

   382 			int leakLineNumber = oneStackItem.getLeakLineNumber();

   383 			String fileName = oneStackItem.getFileName();

   384 			String memAddress = oneStackItem.getMemoryAddress();

   385 			String moduleName = oneStackItem.getModuleName();

   386 

   387 			if (!modules.isEmpty()) {

   388 				to.setBuild(checkItemBuildState(modules, moduleName));

   389 				to.setBelongs(checkProjectModules(modules, moduleName));

   390 			}

   391 

   392 			// report all

   393 			if (Constants.REPORT_EVERY.equals(reportLevel)) {

   394 

   395 				if (leakLineNumber > 0) {

   396 					// if build is urel

   397 					// => change info order

   398 					if (oneStackItem.isUrelBuild()) {

   399 						to.setName(memAddress + " " + moduleName + " "

   400 								+ functionName + " " + leakLineNumber + " "

   401 								+ fileName);

   402 					} else {

   403 						to.setName(memAddress + " " + moduleName + " "

   404 								+ functionName + " " + fileName + " "

   405 								+ leakLineNumber);

   406 					}

   407 

   408 				} else {

   409 					to.setName(memAddress + " " + moduleName + " "

   410 							+ functionName + " " + fileName);

   411 				}

   412 

   413 				to.setCallstackItem(oneStackItem);

   414 				testRuns.addChild(to);

   415 			}

   416 			// display only known lines

   417 			else if (Constants.REPORT_KNOWN.equals(reportLevel)

   418 					&& (functionName != null && leakLineNumber > 0 && fileName != null)) {

   419 				// if build is urel

   420 				// => change info order

   421 				if (oneStackItem.isUrelBuild()) {

   422 					to.setName(memAddress + " " + moduleName + " "

   423 							+ functionName + " " + leakLineNumber + " "

   424 							+ fileName);

   425 				} else {

   426 					to.setName(memAddress + " " + moduleName + " "

   427 							+ functionName + " " + fileName + " "

   428 							+ leakLineNumber);

   429 				}

   430 				to.setCallstackItem(oneStackItem);

   431 				testRuns.addChild(to);

   432 			}

   433 			// display only topmost

   434 			else if (Constants.REPORT_TOPMOST.equals(reportLevel)

   435 					&& !printed

   436 					&& (functionName != null && leakLineNumber > 0 && fileName != null)) {

   437 				// if build is urel

   438 				// => change info order

   439 				if (oneStackItem.isUrelBuild()) {

   440 					to.setName(memAddress + " " + moduleName + " "

   441 							+ functionName + " " + leakLineNumber + " "

   442 							+ fileName);

   443 				} else {

   444 					to.setName(memAddress + " " + moduleName + " "

   445 							+ functionName + " " + fileName + " "

   446 							+ leakLineNumber);

   447 				}

   448 				to.setCallstackItem(oneStackItem);

   449 				testRuns.addChild(to);

   450 				printed = true;

   451 			}

   452 

   453 		}

   454 

   455 		TreeParent incRoot;

   456 		incRoot = new TreeParent(Constants.ANALYZE_TOOL_TITLE);

   457 		incRoot.addChild(testRuns);

   458 		return incRoot;

   459 	}

   460 

   461 	/**

   462 	 * Gets handle leaks tree item.

   463 	 *

   464 	 * @param handleLeaks

   465 	 *            Handle leaks information

   466 	 * @param runID

   467 	 *            Run id

   468 	 * @param modules Selected project target modules

   469 	 * @return Handle leak tree item

   470 	 */

   471 	public final TreeParent getHandleLeakInfo(

   472 			final Hashtable<String, Integer> handleLeaks, final int runID, AbstractList<MMPInfo> modules) {

   473 		// get handle leak information

   474 		TreeParent handleSummary = new TreeParent(

   475 				Constants.HANDLE_LEAK_MODULES_TITLE);

   476 		handleSummary.setRunID(runID);

   477 		for (java.util.Enumeration<String> e1 = handleLeaks.keys(); e1

   478 				.hasMoreElements();) {

   479 			String moduleName = e1.nextElement();

   480 			int handleLeakCount = handleLeaks.get(moduleName);

   481 			TreeObject object = new TreeObject();

   482 			object.setRunID(runID);

   483 			object.setName(moduleName + " (" + handleLeakCount

   484 					+ Constants.MODULE_TREE_HANDLE_LEAKS + ")");

   485 			if (!modules.isEmpty()) {

   486 				object.setBuild(checkItemBuildState(modules, moduleName));

   487 				object.setBelongs(checkProjectModules(modules, moduleName));

   488 			}

   489 

   490 			handleSummary.addChild(object);

   491 		}

   492 		return handleSummary;

   493 	}

   494 

   495 	/**

   496 	 * Gets module leaks tree item.

   497 	 *

   498 	 * @param moduleLeaksInfo

   499 	 *            Module leaks information

   500 	 * @param runID

   501 	 *            Run id

   502 	 * @param modules Selected project target modules

   503 	 * @return Module leak tree item

   504 	 */

   505 	public final TreeParent getModuleLeakInfo(

   506 			final Hashtable<String, Integer> moduleLeaksInfo, final int runID, AbstractList<MMPInfo> modules) {

   507 		TreeParent moduleSummary = new TreeParent(

   508 				Constants.MEMORY_LEAK_MODULES_TITLE);

   509 

   510 		moduleSummary.setRunID(runID);

   511 		for (java.util.Enumeration<String> e = moduleLeaksInfo.keys(); e

   512 				.hasMoreElements();) {

   513 			String moduleName = e.nextElement();

   514 			int moduleLeakCount = moduleLeaksInfo.get(moduleName);

   515 			TreeObject object = new TreeObject();

   516 			object.setRunID(runID);

   517 			object.setName(moduleName + " (" + moduleLeakCount

   518 					+ Constants.MODULE_TREE_MEM_LEAKS + ")");

   519 			if (!modules.isEmpty()) {

   520 				object.setBuild(checkItemBuildState(modules, moduleName));

   521 				object.setBelongs(checkProjectModules(modules, moduleName));

   522 			}

   523 

   524 			moduleSummary.addChild(object);

   525 		}

   526 		return moduleSummary;

   527 	}

   528 

   529 	/**

   530 	 * Return moduleaks info.

   531 	 *

   532 	 * @return Module leaks info

   533 	 */

   534 	public final Hashtable<String, Integer> getCalcModuleLeaksInfo() {

   535 		return moduleLeaks;

   536 	}

   537 

   538 	/**

   539 	 * Gets run tree title.

   540 	 *

   541 	 * @param oneRunResults

   542 	 *            Run results

   543 	 * @param howManyDisplayed

   544 	 *            How many of memory leak items are displayed

   545 	 * @return Run tree title

   546 	 */

   547 	public final String getRunTreeTitle(final RunResults oneRunResults,

   548 			final int howManyDisplayed) {

   549 		StringBuffer runTreeTitle = new StringBuffer(64);

   550 		runTreeTitle.append(Constants.RUN_TREE_RUN);

   551 		runTreeTitle.append(Integer.toString(oneRunResults.getItemID()));

   552 		runTreeTitle.append(Constants.RUN_TREE_RUN_MEM_LEAKS);

   553 		runTreeTitle.append(oneRunResults.getAnalysisItems().size());

   554 		if (howManyDisplayed > 0

   555 				&& oneRunResults.getAnalysisItems().size() != howManyDisplayed) {

   556 			int diff = oneRunResults.getAnalysisItems().size()

   557 					- howManyDisplayed;

   558 			runTreeTitle.append(" (");

   559 			runTreeTitle.append(Integer.toString(diff));

   560 			runTreeTitle.append(Constants.RUN_TREE_FILTERED);

   561 

   562 		}

   563 		runTreeTitle.append(Constants.RUN_TREE_RUN_HANDLE_LEAKS);

   564 		runTreeTitle.append(oneRunResults.getHandleLeakCount());

   565 		runTreeTitle.append(Constants.RUN_TREE_START_TIME);

   566 		runTreeTitle.append(oneRunResults.getStartTime());

   567 		runTreeTitle.append(Constants.RUN_TREE_PROCESS_NAME);

   568 		runTreeTitle.append(oneRunResults.getProcessName());

   569 		runTreeTitle.append(Constants.RUN_TREE_BUILD_TARGET);

   570 		runTreeTitle.append(oneRunResults.getBuildTarget());

   571 

   572 		if (oneRunResults.getEndTime() == null

   573 				|| ("").equals(oneRunResults.getEndTime())) {

   574 			runTreeTitle.append(Constants.RUN_FAILED);

   575 		} else if ((Constants.RUN_ABNORMAL).equals(oneRunResults.getEndTime())) {

   576 			runTreeTitle.append(' ');

   577 			runTreeTitle.append(Constants.RUN_ABNORMAL);

   578 			runTreeTitle.append(' ');

   579 		}

   580 

   581 		return runTreeTitle.toString();

   582 	}

   583 

   584 	/**

   585 	 * Gets subtest title.

   586 	 *

   587 	 * @param oneSubtest

   588 	 *            Subtest info

   589 	 * @param howManyDisplayed

   590 	 *            How many of subtest items are displayed

   591 	 * @return Subtest title

   592 	 */

   593 	public final String getSubtestTreeTitle(final Subtest oneSubtest,

   594 			final int howManyDisplayed) {

   595 		StringBuffer subtestTitle = new StringBuffer(64);

   596 		String startTime = oneSubtest.getStartTime();

   597 		subtestTitle.append(Constants.SUBTEST_TREE_TITLE);

   598 		subtestTitle.append(oneSubtest.getName());

   599 		subtestTitle.append(Constants.RUN_TREE_RUN_MEM_LEAKS);

   600 		subtestTitle.append(oneSubtest.getAnalysisItems().size());

   601 

   602 		if (howManyDisplayed > 0

   603 				&& oneSubtest.getAnalysisItems().size() != howManyDisplayed) {

   604 			int diff = oneSubtest.getAnalysisItems().size() - howManyDisplayed;

   605 

   606 			subtestTitle.append(" (");

   607 			subtestTitle.append(diff);

   608 			subtestTitle.append(Constants.RUN_TREE_FILTERED);

   609 		}

   610 		subtestTitle.append(Constants.RUN_TREE_RUN_HANDLE_LEAKS);

   611 		subtestTitle.append(oneSubtest.getHandleLeakCount());

   612 		if (startTime.length() != 0) {

   613 			subtestTitle.append(Constants.RUN_TREE_START_TIME);

   614 			subtestTitle.append(oneSubtest.getStartTime());

   615 		}

   616 		return subtestTitle.toString();

   617 	}

   618 

   619 	/**

   620 	 * Updates module leak count for current module.

   621 	 *

   622 	 * @param moduleName

   623 	 *            Module name

   624 	 */

   625 	public final void updateModuleLeaksInfo(final String moduleName) {

   626 

   627 		//check module name

   628 		if( moduleName == null || ("").equals(moduleName) ) {

   629 			return;

   630 		}

   631 		//if same module name is already added => update count value

   632 		else if (moduleLeaks.containsKey(moduleName)) {

   633 			int currentCount = moduleLeaks.get(moduleName);

   634 			currentCount++;

   635 			moduleLeaks.put(moduleName, currentCount);

   636 		} else {

   637 			moduleLeaks.put(moduleName, 1);

   638 		}

   639 	}

   640 }