analysis/org.eclipse.tracecompass.analysis.timing.core.tests/src/org/eclipse/tracecompass/analysis/timing/core/tests/flamegraph/AggregatedCalledFunctionStatisticsTest.java

   1 package org.eclipse.tracecompass.analysis.timing.core.tests.flamegraph;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertNotNull;
   5 import static org.junit.Assert.assertTrue;
   6
   7 import java.util.Collections;
   8 import java.util.List;
   9
  10 import org.eclipse.core.runtime.IProgressMonitor;
  11 import org.eclipse.core.runtime.NullProgressMonitor;
  12 import org.eclipse.jdt.annotation.NonNull;
  13 import org.eclipse.jdt.annotation.Nullable;
  14 import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.AggregatedCalledFunction;
  15 import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.AggregatedCalledFunctionStatistics;
  16 import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.CallGraphAnalysis;
  17 import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.ThreadNode;
  18 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
  19 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder;
  20 import org.eclipse.tracecompass.statesystem.core.StateSystemFactory;
  21 import org.eclipse.tracecompass.statesystem.core.backend.IStateHistoryBackend;
  22 import org.eclipse.tracecompass.statesystem.core.backend.StateHistoryBackendFactory;
  23 import org.eclipse.tracecompass.statesystem.core.statevalue.TmfStateValue;
  24 import org.eclipse.tracecompass.tmf.core.segment.ISegmentAspect;
  25 import org.junit.Test;
  26
  27 /**
  28  * Test the statistics of each node in the aggregation tree. This creates a
  29  * virtual state system in each test then tests the statistics of the
  30  * aggregation tree returned by CallGraphAnalysis.
  31  *
  32  * @author Sonia Farrah
  33  *
  34  */
  35 public class AggregatedCalledFunctionStatisticsTest {
  36     private static final @NonNull String PROCESS_PATH = "Processes";
  37     private static final @NonNull String THREAD_PATH = "Thread";
  38     private static final @NonNull String CALLSTACK_PATH = "CallStack";
  39     private static final String QUARK_0 = "0";
  40     private static final String QUARK_1 = "1";
  41     private static final String QUARK_2 = "2";
  42     private static final String QUARK_3 = "3";
  43     private static final String @NonNull [] CSP = { CALLSTACK_PATH };
  44     private static final String @NonNull [] PP = { PROCESS_PATH };
  45     private static final String @NonNull [] TP = { THREAD_PATH };
  46     private static final double ERROR = 0.000001;
  47
  48     /**
  49      * This class is used to make the CallGraphAnalysis's method
  50      * iterateOverStateSystem() visible to test
  51      */
  52     private class CGAnalysis extends CallGraphAnalysis {
  53
  54         @Override
  55         protected boolean iterateOverStateSystem(@Nullable ITmfStateSystem ss, String[] threadsPattern, String[] processesPattern, String[] callStackPath, IProgressMonitor monitor) {
  56             return super.iterateOverStateSystem(ss, threadsPattern, processesPattern, callStackPath, monitor);
  57         }
  58
  59         @Override
  60         public @NonNull Iterable<@NonNull ISegmentAspect> getSegmentAspects() {
  61             return Collections.EMPTY_LIST;
  62         }
  63     }
  64
  65     private static ITmfStateSystemBuilder createFixture() {
  66         IStateHistoryBackend backend;
  67         backend = StateHistoryBackendFactory.createInMemoryBackend("Test", 0L);
  68         ITmfStateSystemBuilder fixture = StateSystemFactory.newStateSystem(backend);
  69         return fixture;
  70     }
  71
  72     /**
  73      * The call stack's structure used in this test is shown below:
  74      *
  75      * <pre>
  76      *                 Aggregated tree
  77      *  ___ main___      ___ main___
  78      *   _1_    _1_  =>      _1_
  79      *   _1_                 _1_
  80      * </pre>
  81      */
  82     @Test
  83     public void TreeStatisticsTest() {
  84         ITmfStateSystemBuilder fixture = createFixture();
  85         // Build the state system
  86         int parentQuark = fixture.getQuarkAbsoluteAndAdd(PROCESS_PATH, THREAD_PATH, CALLSTACK_PATH);
  87         int quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_0);
  88         TmfStateValue statev = TmfStateValue.newValueLong(0);
  89         fixture.modifyAttribute(0, statev, quark);
  90         fixture.modifyAttribute(100, TmfStateValue.nullValue(), quark);
  91
  92         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_1);
  93         statev = TmfStateValue.newValueLong(1);
  94         fixture.modifyAttribute(0, statev, quark);
  95         fixture.modifyAttribute(50, TmfStateValue.nullValue(), quark);
  96         fixture.modifyAttribute(60, statev, quark);
  97         fixture.modifyAttribute(90, TmfStateValue.nullValue(), quark);
  98
  99         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_2);
 100         fixture.modifyAttribute(0, statev, quark);
 101         fixture.modifyAttribute(30, TmfStateValue.nullValue(), quark);
 102         fixture.closeHistory(102);
 103
 104         // Execute the CallGraphAnalysis
 105         CGAnalysis cga = new CGAnalysis();
 106         assertTrue(cga.iterateOverStateSystem(fixture, TP, PP, CSP, new NullProgressMonitor()));
 107         @NonNull
 108         List<ThreadNode> threads = cga.getThreadNodes();
 109         // Test the threads generated by the analysis
 110         assertNotNull(threads);
 111         Object[] children = threads.get(0).getChildren().toArray();
 112         AggregatedCalledFunction firstFunction = (AggregatedCalledFunction) children[0];
 113         Object[] firstFunctionChildren = firstFunction.getChildren().toArray();
 114         AggregatedCalledFunction SecondFunction = (AggregatedCalledFunction) firstFunctionChildren[0];
 115         Object[] secondFunctionChildren = SecondFunction.getChildren().toArray();
 116         AggregatedCalledFunction ThirdFunction = (AggregatedCalledFunction) secondFunctionChildren[0];
 117         // Test the main statistics
 118         @NonNull
 119         AggregatedCalledFunctionStatistics mainStatistics1 = firstFunction.getFunctionStatistics();
 120         assertEquals("Test main's maximum duration", 100, mainStatistics1.getMax());
 121         assertEquals("Test main's minimum duration", 100, mainStatistics1.getMin());
 122         assertEquals("Test main's maximum self time", 20, mainStatistics1.getMaxSelfTime());
 123         assertEquals("Test main's minimum self time", 20, mainStatistics1.getMinSelfTime());
 124         assertEquals("Test main's number of calls", 1, mainStatistics1.getNbSegments());
 125         assertEquals("Test main's average duration", 100, mainStatistics1.getAverage(), ERROR);
 126         assertEquals("Test main's standard deviation", 20, mainStatistics1.getAverageSelfTime(), ERROR);
 127         assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getStdDev(), ERROR);
 128         assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getStdDevSelfTime(), ERROR);
 129         // Test the first function statistics
 130         @NonNull
 131         AggregatedCalledFunctionStatistics functionStatistics1 = SecondFunction.getFunctionStatistics();
 132         assertEquals("Test first function's maximum duration", 50, functionStatistics1.getMax());
 133         assertEquals("Test first function's minimum duration", 30, functionStatistics1.getMin());
 134         assertEquals("Test first function's maximum self time", 30, functionStatistics1.getMaxSelfTime());
 135         assertEquals("Test first function's mininmum self time", 20, functionStatistics1.getMinSelfTime());
 136         assertEquals("Test first function's number of calls", 2, functionStatistics1.getNbSegments());
 137         assertEquals("Test first function's average duration", 40, functionStatistics1.getAverage(), ERROR);
 138         assertEquals("Test first function's average self time", 25, functionStatistics1.getAverageSelfTime(), ERROR);
 139         assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDev(), ERROR);
 140         assertEquals("Test first function's self time standard deviation", Double.NaN, functionStatistics1.getStdDevSelfTime(), ERROR);
 141         // Test the third function statistics
 142         @NonNull
 143         AggregatedCalledFunctionStatistics functionStatistics2 = ThirdFunction.getFunctionStatistics();
 144         assertEquals("Test second function's maximum duration", 30, functionStatistics2.getMax());
 145         assertEquals("Test second function's minimum duration", 30, functionStatistics2.getMin());
 146         assertEquals("Test second function's maximum self time", 30, functionStatistics2.getMaxSelfTime());
 147         assertEquals("Test second function's minimum self time", 30, functionStatistics2.getMinSelfTime());
 148         assertEquals("Test second function's number of calls", 1, functionStatistics2.getNbSegments());
 149         assertEquals("Test second function's average duration", 30, functionStatistics2.getAverage(), ERROR);
 150         assertEquals("Test second function's average self time", 30, functionStatistics2.getAverageSelfTime(), ERROR);
 151         assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDev(), ERROR);
 152         assertEquals("Test second function's self time standard deviation", Double.NaN, functionStatistics2.getStdDevSelfTime(), ERROR);
 153     }
 154
 155     /**
 156      * The call stack's structure used in this test is shown below:
 157      *
 158      * <pre>
 159      *                    Aggregated tree
 160      *  ___ main___        ___ main___
 161      *   _1_    _1_ =>         _1_
 162      *   _2_    _3_          _2_ _3_
 163      * </pre>
 164      */
 165     @Test
 166     public void MergeFirstLevelCalleesStatisticsTest() {
 167         ITmfStateSystemBuilder fixture = createFixture();
 168         // Build the state system
 169         int parentQuark = fixture.getQuarkAbsoluteAndAdd(PROCESS_PATH, THREAD_PATH, CALLSTACK_PATH);
 170         int quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_0);
 171         TmfStateValue statev = TmfStateValue.newValueLong(0);
 172         fixture.modifyAttribute(0, statev, quark);
 173         fixture.modifyAttribute(100, TmfStateValue.nullValue(), quark);
 174
 175         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_1);
 176         statev = TmfStateValue.newValueLong(1);
 177         fixture.modifyAttribute(0, statev, quark);
 178         fixture.modifyAttribute(50, TmfStateValue.nullValue(), quark);
 179         fixture.modifyAttribute(60, statev, quark);
 180         fixture.modifyAttribute(90, TmfStateValue.nullValue(), quark);
 181
 182         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_2);
 183         statev = TmfStateValue.newValueLong(2);
 184         fixture.modifyAttribute(0, statev, quark);
 185         fixture.modifyAttribute(30, TmfStateValue.nullValue(), quark);
 186         statev = TmfStateValue.newValueLong(3);
 187         fixture.modifyAttribute(60, statev, quark);
 188         fixture.modifyAttribute(80, TmfStateValue.nullValue(), quark);
 189         fixture.closeHistory(102);
 190
 191         // Execute the CallGraphAnalysis
 192         CGAnalysis cga = new CGAnalysis();
 193         assertTrue(cga.iterateOverStateSystem(fixture, TP, PP, CSP, new NullProgressMonitor()));
 194         List<ThreadNode> threads = cga.getThreadNodes();
 195         assertNotNull(threads);
 196         Object[] children = threads.get(0).getChildren().toArray();
 197         AggregatedCalledFunction firstFunction = (AggregatedCalledFunction) children[0];
 198         Object[] firstFunctionChildren = firstFunction.getChildren().toArray();
 199         AggregatedCalledFunction secondFunction = (AggregatedCalledFunction) firstFunctionChildren[0];
 200         Object[] secondFunctionChildren = secondFunction.getChildren().toArray();
 201         AggregatedCalledFunction leaf1 = (AggregatedCalledFunction) secondFunctionChildren[0];
 202         AggregatedCalledFunction leaf2 = (AggregatedCalledFunction) secondFunctionChildren[1];
 203         // Test the first function statistics
 204         @NonNull
 205         AggregatedCalledFunctionStatistics functionStatistics1 = firstFunction.getFunctionStatistics();
 206         assertEquals("Test first function's maximum duration", 100, functionStatistics1.getMax());
 207         assertEquals("Test first function's minimum duration", 100, functionStatistics1.getMin());
 208         assertEquals("Test first function's maximum self time", 20, functionStatistics1.getMaxSelfTime());
 209         assertEquals("Test first function's minimum self time", 20, functionStatistics1.getMinSelfTime());
 210         assertEquals("Test first function's number of segments", 1, functionStatistics1.getNbSegments());
 211         assertEquals("Test first function's average duration", 100, functionStatistics1.getAverage(), ERROR);
 212         assertEquals("Test first function's average self time", 20, functionStatistics1.getAverageSelfTime(), ERROR);
 213         assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDev(), ERROR);
 214         assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDevSelfTime(), ERROR);
 215         // Test the first function statistics
 216         @NonNull
 217         AggregatedCalledFunctionStatistics functionStatistics2 = secondFunction.getFunctionStatistics();
 218         assertEquals("Test second function's maximum duration", 50, functionStatistics2.getMax());
 219         assertEquals("Test second function's minimum duration", 30, functionStatistics2.getMin());
 220         assertEquals("Test second function's maximum self time", 20, functionStatistics2.getMaxSelfTime());
 221         assertEquals("Test second function's minimum self time", 10, functionStatistics2.getMinSelfTime());
 222         assertEquals("Test second function's number of calls", 2, functionStatistics2.getNbSegments());
 223         assertEquals("Test second function's average duration", 40, functionStatistics2.getAverage(), ERROR);
 224         assertEquals("Test second function's average self time", 15, functionStatistics2.getAverageSelfTime(), ERROR);
 225         assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDev(), ERROR);
 226         assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDevSelfTime(), ERROR);
 227         // Test the first leaf statistics
 228         @NonNull
 229         AggregatedCalledFunctionStatistics leafStatistics1 = leaf1.getFunctionStatistics();
 230         assertEquals("Test first leaf's maximum duration", 30, leafStatistics1.getMax());
 231         assertEquals("Test first leaf's minimum duration", 30, leafStatistics1.getMin());
 232         assertEquals("Test first leaf's maximum self time", 30, leafStatistics1.getMaxSelfTime());
 233         assertEquals("Test first leaf's minimum self time", 30, leafStatistics1.getMinSelfTime());
 234         assertEquals("Test first leaf's number of calls", 1, leafStatistics1.getNbSegments());
 235         assertEquals("Test first leaf's minimum duration", 30, leafStatistics1.getAverage(), ERROR);
 236         assertEquals("Test first leaf's average self time", 30, leafStatistics1.getAverageSelfTime(), ERROR);
 237         assertEquals("Test first leaf's standard deviation", Double.NaN, leafStatistics1.getStdDev(), ERROR);
 238         assertEquals("Test first leaf's self time standard deviation", Double.NaN, leafStatistics1.getStdDevSelfTime(), ERROR);
 239         // Test the second leaf statistics
 240         @NonNull
 241         AggregatedCalledFunctionStatistics leafStatistics2 = leaf2.getFunctionStatistics();
 242         assertEquals("Test second leaf's maximum duration", 20, leafStatistics2.getMax());
 243         assertEquals("Test second leaf's minimum duration", 20, leafStatistics2.getMin());
 244         assertEquals("Test second leaf's maximum self time", 20, leafStatistics2.getMaxSelfTime());
 245         assertEquals("Test second leaf's minimum self time", 20, leafStatistics2.getMinSelfTime());
 246         assertEquals("Test second leaf's number of calls", 1, leafStatistics2.getNbSegments());
 247         assertEquals("Test second leaf's average duration", 20, leafStatistics2.getAverage(), ERROR);
 248         assertEquals("Test second leaf's average self time", 20, leafStatistics2.getAverageSelfTime(), ERROR);
 249         assertEquals("Test second leaf's standard deviation", Double.NaN, leafStatistics2.getStdDev(), ERROR);
 250         assertEquals("Test second leaf's self time standard deviation", Double.NaN, leafStatistics2.getStdDevSelfTime(), ERROR);
 251
 252     }
 253
 254     /**
 255      * The call stack's structure used in this test is shown below:
 256      *
 257      * <pre>
 258      *              Aggregated tree
 259      * _1_  _1_  =>    _1_
 260      * _2_  _3_      _2_ _3_
 261      * </pre>
 262      */
 263     @Test
 264     public void multiFunctionRootsTest() {
 265         ITmfStateSystemBuilder fixture = createFixture();
 266         int parentQuark = fixture.getQuarkAbsoluteAndAdd(PROCESS_PATH, THREAD_PATH, CALLSTACK_PATH);
 267         // Create the first root function
 268         int quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_0);
 269         TmfStateValue statev = TmfStateValue.newValueLong(1);
 270         fixture.modifyAttribute(0, statev, quark);
 271         fixture.modifyAttribute(20, TmfStateValue.nullValue(), quark);
 272         // Create the second root function
 273         fixture.modifyAttribute(30, statev, quark);
 274         fixture.modifyAttribute(80, TmfStateValue.nullValue(), quark);
 275         // Create the first root function's callee
 276         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_1);
 277         statev = TmfStateValue.newValueLong(2);
 278         fixture.modifyAttribute(0, statev, quark);
 279         fixture.modifyAttribute(10, TmfStateValue.nullValue(), quark);
 280         // Create the second root function's callee
 281         statev = TmfStateValue.newValueLong(3);
 282         fixture.modifyAttribute(30, statev, quark);
 283         fixture.modifyAttribute(40, TmfStateValue.nullValue(), quark);
 284         fixture.closeHistory(81);
 285
 286         // Execute the callGraphAnalysis
 287         CGAnalysis cga = new CGAnalysis();
 288         assertTrue(cga.iterateOverStateSystem(fixture, TP, PP, CSP, new NullProgressMonitor()));
 289         List<ThreadNode> threads = cga.getThreadNodes();
 290         // Test the threads generated by the analysis
 291         assertNotNull(threads);
 292         Object[] children = threads.get(0).getChildren().toArray();
 293         AggregatedCalledFunction firstFunction = (AggregatedCalledFunction) children[0];
 294         Object[] firstFunctionChildren = firstFunction.getChildren().toArray();
 295         AggregatedCalledFunction function2 = (AggregatedCalledFunction) firstFunctionChildren[0];
 296         AggregatedCalledFunction function3 = (AggregatedCalledFunction) firstFunctionChildren[1];
 297         // Test the first function statistics
 298         @NonNull
 299         AggregatedCalledFunctionStatistics functionStatistics1 = firstFunction.getFunctionStatistics();
 300         assertEquals("Test first function's maximum duration", 50, functionStatistics1.getMax());
 301         assertEquals("Test first function's minimum duration", 20, functionStatistics1.getMin());
 302         assertEquals("Test first function's maximum self time", 40, functionStatistics1.getMaxSelfTime());
 303         assertEquals("Test first function's minimum self time", 10, functionStatistics1.getMinSelfTime());
 304         assertEquals("Test first function's number of segments", 2, functionStatistics1.getNbSegments());
 305         assertEquals("Test first function's average duration", 35, functionStatistics1.getAverage(), ERROR);
 306         assertEquals("Test first function's average self time", 25, functionStatistics1.getAverageSelfTime(), ERROR);
 307         assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDev(), ERROR);
 308         assertEquals("Test first function's self time standard deviation", Double.NaN, functionStatistics1.getStdDevSelfTime(), ERROR);
 309         // Test the second function statistics
 310         @NonNull
 311         AggregatedCalledFunctionStatistics functionStatistics2 = function2.getFunctionStatistics();
 312         assertEquals("Test second function's maximum duration", 10, functionStatistics2.getMax());
 313         assertEquals("Test second function's minimum duration", 10, functionStatistics2.getMin());
 314         assertEquals("Test second function's maximum self time", 10, functionStatistics2.getMaxSelfTime());
 315         assertEquals("Test second function's minimum self time", 10, functionStatistics2.getMinSelfTime());
 316         assertEquals("Test second function's number of calls", 1, functionStatistics2.getNbSegments());
 317         assertEquals("Test second function's average duration", 10, functionStatistics2.getAverage(), ERROR);
 318         assertEquals("Test second function's average self time", 10, functionStatistics2.getAverageSelfTime(), ERROR);
 319         assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDev(), ERROR);
 320         assertEquals("Test second function's self time standard deviation", Double.NaN, functionStatistics2.getStdDevSelfTime(), ERROR);
 321         // Test the third function statistics
 322         @NonNull
 323         AggregatedCalledFunctionStatistics functionStatistics3 = function3.getFunctionStatistics();
 324         assertEquals("Test third function's maximum duration", 10, functionStatistics3.getMax());
 325         assertEquals("Test third function's minimum duration", 10, functionStatistics3.getMin());
 326         assertEquals("Test third function's maximum selftime", 10, functionStatistics3.getMaxSelfTime());
 327         assertEquals("Test third function's minimum self time", 10, functionStatistics3.getMinSelfTime());
 328         assertEquals("Test third function's number of calls", 1, functionStatistics3.getNbSegments());
 329         assertEquals("Test third function's average duration", 10, functionStatistics3.getAverage(), ERROR);
 330         assertEquals("Test third function's average self time", 10, functionStatistics3.getAverageSelfTime(), ERROR);
 331         assertEquals("Test third function's standard deviation", Double.NaN, functionStatistics3.getStdDev(), ERROR);
 332         assertEquals("Test third function's self time standard deviation", Double.NaN, functionStatistics3.getStdDevSelfTime(), ERROR);
 333     }
 334
 335     /**
 336      * Build a call stack example.This call stack's structure is shown below :
 337      *
 338      * <pre>
 339      *      ___ main____
 340      *  ___1___    _1_  _1_
 341      *  _2_ _3_    _2_
 342      *  _4_        _4_
 343      * </pre>
 344      */
 345     private static void buildCallStack(ITmfStateSystemBuilder fixture) {
 346         int parentQuark = fixture.getQuarkAbsoluteAndAdd(PROCESS_PATH, THREAD_PATH, CALLSTACK_PATH);
 347         // Create the first function
 348         int quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_0);
 349         TmfStateValue statev = TmfStateValue.newValueLong(0);
 350         fixture.modifyAttribute(0, statev, quark);
 351         fixture.modifyAttribute(150, TmfStateValue.nullValue(), quark);
 352         // Create the first level functions
 353         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_1);
 354         statev = TmfStateValue.newValueLong(1);
 355         fixture.modifyAttribute(0, statev, quark);
 356         fixture.modifyAttribute(50, TmfStateValue.nullValue(), quark);
 357         fixture.modifyAttribute(60, statev, quark);
 358         fixture.modifyAttribute(100, TmfStateValue.nullValue(), quark);
 359         fixture.modifyAttribute(130, statev, quark);
 360         fixture.modifyAttribute(150, TmfStateValue.nullValue(), quark);
 361         // Create the third function
 362         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_2);
 363         statev = TmfStateValue.newValueLong(2);
 364         fixture.modifyAttribute(0, statev, quark);
 365         fixture.modifyAttribute(10, TmfStateValue.nullValue(), quark);
 366
 367         statev = TmfStateValue.newValueLong(3);
 368         fixture.modifyAttribute(20, statev, quark);
 369         fixture.modifyAttribute(30, TmfStateValue.nullValue(), quark);
 370
 371         statev = TmfStateValue.newValueLong(2);
 372         fixture.modifyAttribute(60, statev, quark);
 373         fixture.modifyAttribute(90, TmfStateValue.nullValue(), quark);
 374
 375         quark = fixture.getQuarkRelativeAndAdd(parentQuark, QUARK_3);
 376         statev = TmfStateValue.newValueLong(4);
 377         fixture.modifyAttribute(0, statev, quark);
 378         fixture.modifyAttribute(10, TmfStateValue.nullValue(), quark);
 379
 380         fixture.modifyAttribute(60, statev, quark);
 381         fixture.modifyAttribute(80, TmfStateValue.nullValue(), quark);
 382         fixture.closeHistory(151);
 383     }
 384
 385     /**
 386      * The call stack's structure used in this test is shown below:
 387      *
 388      * <pre>
 389      *                          Aggregated tree
 390      *     ___ main____          ____ main____
 391      *  ___1___    _1_ _1_            _1_
 392      *  _2_ _3_    _2_      =>      _2_ _3_
 393      *  _4_        _4_              _4_
 394      * </pre>
 395      */
 396     @Test
 397     public void MergeSecondLevelCalleesTest() {
 398         ITmfStateSystemBuilder fixture = createFixture();
 399
 400         buildCallStack(fixture);
 401         // Execute the CallGraphAnalysis
 402         CGAnalysis cga = new CGAnalysis();
 403         assertTrue(cga.iterateOverStateSystem(fixture, TP, PP, CSP, new NullProgressMonitor()));
 404         List<ThreadNode> threads = cga.getThreadNodes();
 405         // Test the threads generated by the analysis
 406         assertNotNull(threads);
 407         // Test the threads generated by the analysis
 408         assertNotNull(threads);
 409         Object[] children = threads.get(0).getChildren().toArray();
 410         AggregatedCalledFunction main = (AggregatedCalledFunction) children[0];
 411         Object[] mainChildren = main.getChildren().toArray();
 412         AggregatedCalledFunction function1 = (AggregatedCalledFunction) mainChildren[0];
 413         Object[] firstFunctionChildren = function1.getChildren().toArray();
 414         AggregatedCalledFunction function2 = (AggregatedCalledFunction) firstFunctionChildren[0];
 415         AggregatedCalledFunction function3 = (AggregatedCalledFunction) firstFunctionChildren[1];
 416         Object[] firstChildCallee = function2.getChildren().toArray();
 417         AggregatedCalledFunction function4 = (AggregatedCalledFunction) firstChildCallee[0];
 418         // Test the main function statistics
 419         AggregatedCalledFunctionStatistics mainStatistics1 = main.getFunctionStatistics();
 420         assertEquals("Test main's maximum duration", 150, mainStatistics1.getMax());
 421         assertEquals("Test main's minimum duration", 150, mainStatistics1.getMin());
 422         assertEquals("Test main's maximum self time", 40, mainStatistics1.getMaxSelfTime());
 423         assertEquals("Test main's minimum self time", 40, mainStatistics1.getMinSelfTime());
 424         assertEquals("Test main's number of calls", 1, mainStatistics1.getNbSegments());
 425         assertEquals("Test main's average duration", 150, mainStatistics1.getAverage(), ERROR);
 426         assertEquals("Test main's average self time", 40, mainStatistics1.getAverageSelfTime(), ERROR);
 427         assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getStdDev(), ERROR);
 428         assertEquals("Test main's self time standard deviation", Double.NaN, mainStatistics1.getStdDevSelfTime(), ERROR);
 429         // Test the first function statistics
 430         AggregatedCalledFunctionStatistics firstFunctionStatistics = function1.getFunctionStatistics();
 431         assertEquals("Test first function's maximum duration", 50, firstFunctionStatistics.getMax());
 432         assertEquals("Test first function's minimum duration", 20, firstFunctionStatistics.getMin());
 433         assertEquals("Test first function's maximum self time", 30, firstFunctionStatistics.getMaxSelfTime());
 434         assertEquals("Test first function's minimum self time", 10, firstFunctionStatistics.getMinSelfTime());
 435         assertEquals("Test first function's number of segments", 3, firstFunctionStatistics.getNbSegments());
 436         assertEquals("Test first function's average duration", 36.666666667, firstFunctionStatistics.getAverage(), ERROR);
 437         assertEquals("Test first function's average self time", 20, firstFunctionStatistics.getAverageSelfTime(), ERROR);
 438         assertEquals("Test first function's standard deviation", 15.275252316, firstFunctionStatistics.getStdDev(), ERROR);
 439         assertEquals("Test first function's self time standard deviation", 10, firstFunctionStatistics.getStdDevSelfTime(), ERROR);
 440         // Test the second function statistics
 441         AggregatedCalledFunctionStatistics secondFunctionStatistics2 = function2.getFunctionStatistics();
 442         assertEquals("Test second function's maximum duration", 30, secondFunctionStatistics2.getMax());
 443         assertEquals("Test second function's minimum duration", 10, secondFunctionStatistics2.getMin());
 444         assertEquals("Test second function's maximum self time", 10, secondFunctionStatistics2.getMaxSelfTime());
 445         assertEquals("Test second function's minimum self time", 0, secondFunctionStatistics2.getMinSelfTime());
 446         assertEquals("Test second function's number of segments", 2, secondFunctionStatistics2.getNbSegments());
 447         assertEquals("Test second function's average duration", 20, secondFunctionStatistics2.getAverage(), ERROR);
 448         assertEquals("Test second function's average self time", 5, secondFunctionStatistics2.getAverageSelfTime(), ERROR);
 449         assertEquals("Test second function's standard deviation", Double.NaN, secondFunctionStatistics2.getStdDev(), ERROR);
 450         assertEquals("Test second function's self time standard deviation", Double.NaN, secondFunctionStatistics2.getStdDevSelfTime(), ERROR);
 451         // Test the third function statistics
 452         AggregatedCalledFunctionStatistics thirdFunctionStatistics3 = function3.getFunctionStatistics();
 453         assertEquals("Test third function's maximum duration", 10, thirdFunctionStatistics3.getMax());
 454         assertEquals("Test third function's minimum duration", 10, thirdFunctionStatistics3.getMin());
 455         assertEquals("Test third function's maximum self time", 10, thirdFunctionStatistics3.getMaxSelfTime());
 456         assertEquals("Test third function's minimum self time", 10, thirdFunctionStatistics3.getMinSelfTime());
 457         assertEquals("Test third function's number of segments", 1, thirdFunctionStatistics3.getNbSegments());
 458         assertEquals("Test third function's average duration", 10, thirdFunctionStatistics3.getAverage(), ERROR);
 459         assertEquals("Test third function's average self time", 10, thirdFunctionStatistics3.getAverageSelfTime(), ERROR);
 460         assertEquals("Test third function's self time deviation", Double.NaN, thirdFunctionStatistics3.getStdDev(), ERROR);
 461         assertEquals("Test third function's self time standard deviation", Double.NaN, thirdFunctionStatistics3.getStdDev(), ERROR);
 462         // Test the fourth function statistics
 463         AggregatedCalledFunctionStatistics fourthFunctionStatistics4 = function4.getFunctionStatistics();
 464         assertEquals("Test fourth function's maximum duration", 20, fourthFunctionStatistics4.getMax());
 465         assertEquals("Test fourth function's minimum duration", 10, fourthFunctionStatistics4.getMin());
 466         assertEquals("Test fourth function's maximum self time", 20, fourthFunctionStatistics4.getMaxSelfTime());
 467         assertEquals("Test fourth function's maximum self time", 10, fourthFunctionStatistics4.getMinSelfTime());
 468         assertEquals("Test fourth function's number of segments", 2, fourthFunctionStatistics4.getNbSegments());
 469         assertEquals("Test fourth function's average duration", 15, fourthFunctionStatistics4.getAverage(), ERROR);
 470         assertEquals("Test fourth function's average duration", 15, fourthFunctionStatistics4.getAverageSelfTime(), ERROR);
 471         assertEquals("Test fourth function's standard deviation", Double.NaN, fourthFunctionStatistics4.getStdDev(), ERROR);
 472         assertEquals("Test fourth function's self time deviation", Double.NaN, fourthFunctionStatistics4.getStdDevSelfTime(), ERROR);
 473     }
 474
 475 }