projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add some more model test cases for LTTng 2.0 control
[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng2.ui.tests / src / org / eclipse / linuxtools / lttng2 / ui / tests / control / model / component / TraceControlKernelSessionTests.java
CommitLineData
a26d90be
BH		 1/**********************************************************************
2 * Copyright (c) 2012 Ericsson
3 *
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * Bernd Hufmann - Initial API and implementation
11 **********************************************************************/
12package org.eclipse.linuxtools.lttng2.ui.tests.control.model.component;
13
14import java.io.File;
15import java.net.URL;
16import java.util.ArrayList;
17import java.util.List;
18
19import junit.framework.Test;
20import junit.framework.TestCase;
21import junit.framework.TestSuite;
22
23import org.eclipse.core.runtime.FileLocator;
24import org.eclipse.core.runtime.Path;
25import org.eclipse.linuxtools.internal.lttng2.stubs.dialogs.CreateChannelDialogStub;
26import org.eclipse.linuxtools.internal.lttng2.stubs.dialogs.CreateSessionDialogStub;
27import org.eclipse.linuxtools.internal.lttng2.stubs.dialogs.DestroyConfirmDialogStub;
28import org.eclipse.linuxtools.internal.lttng2.stubs.dialogs.EnableEventsDialogStub;
29import org.eclipse.linuxtools.internal.lttng2.stubs.dialogs.GetEventInfoDialogStub;
30import org.eclipse.linuxtools.internal.lttng2.stubs.service.TestRemoteSystemProxy;
31import org.eclipse.linuxtools.internal.lttng2.ui.views.control.dialogs.TraceControlDialogFactory;
32import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.ITraceControlComponent;
33import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.TargetNodeState;
34import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.TraceEnablement;
35import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.TraceEventType;
36import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.TraceLogLevel;
37import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.TraceSessionState;
38import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl.ChannelInfo;
39import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl.TargetNodeComponent;
40import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl.TraceChannelComponent;
41import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl.TraceEventComponent;
42import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl.TraceProbeEventComponent;
43import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl.TraceSessionComponent;
44import org.eclipse.linuxtools.lttng2.ui.tests.Activator;
45import org.eclipse.rse.core.model.Host;
46import org.eclipse.rse.core.model.IHost;
47import org.eclipse.rse.internal.core.model.SystemProfile;
48import org.junit.After;
49import org.junit.Before;
50
51/**
52 * The class <code>TraceControlKernelSessionTests</code> contains UST session/channel/event
53 * handling test cases.
54 */
55
56@SuppressWarnings("nls")
57public class TraceControlKernelSessionTests extends TestCase {
58
59 // ------------------------------------------------------------------------
60 // Constants
61 // ------------------------------------------------------------------------
62 private static final String TEST_STREAM = "CreateTreeTest.cfg";
63 private static final String SCEN_SCENARIO3_TEST = "Scenario3";
64
65 // ------------------------------------------------------------------------
66 // Test data
67 // ------------------------------------------------------------------------
68 private TraceControlTestFacility fFacility;
69 private TestRemoteSystemProxy fProxy;
70 private String fTestFile;
71
72 // ------------------------------------------------------------------------
73 // Static methods
74 // ------------------------------------------------------------------------
75
76 /**
77 * Returns test setup used when executing test case stand-alone.
78 * @return Test setup class
79 */
80 public static Test suite() {
81 return new ModelImplTestSetup(new TestSuite(TraceControlKernelSessionTests.class));
82 }
83
84 // ------------------------------------------------------------------------
85 // Housekeeping
86 // ------------------------------------------------------------------------
87
88 /**
89 * Perform pre-test initialization.
90 *
91 * @throws Exception
92 * if the initialization fails for some reason
93 *
94 */
95 @Override
96 @Before
97 public void setUp() throws Exception {
98 fFacility = TraceControlTestFacility.getInstance();
99 fProxy = new TestRemoteSystemProxy();
100 URL location = FileLocator.find(Activator.getDefault().getBundle(), new Path(TraceControlTestFacility.DIRECTORY + File.separator + TEST_STREAM), null);
101 File testfile = new File(FileLocator.toFileURL(location).toURI());
102 fTestFile = testfile.getAbsolutePath();
103 }
104
105 /**
106 * Perform post-test clean-up.
107 *
108 * @throws Exception
109 * if the clean-up fails for some reason
110 *
111 */
112 @Override
113 @After
114 public void tearDown() throws Exception {
115 }
116
117 /**
118 * Run the TraceControlComponent.
119 */
120 public void testTraceSessionTree() throws Exception {
121
122 fProxy.setTestFile(fTestFile);
123 fProxy.setScenario(TraceControlTestFacility.SCEN_INIT_TEST);
124
125 ITraceControlComponent root = TraceControlTestFacility.getInstance().getControlView().getTraceControlRoot();
126
127 @SuppressWarnings("restriction")
128 IHost host = new Host(new SystemProfile("myProfile", true));
129 host.setHostName("127.0.0.1");
130
131 TargetNodeComponent node = new TargetNodeComponent("myNode", root, host, fProxy);
132
133 root.addChild(node);
134 node.connect();
135
136 fFacility.waitForJobs();
137
138 // Verify that node is connected
139 assertEquals(TargetNodeState.CONNECTED, node.getTargetNodeState());
140
141 // Get provider groups
142 ITraceControlComponent[] groups = node.getChildren();
143 assertNotNull(groups);
144 assertEquals(2, groups.length);
145
146 // Initialize dialog implementations for command execution
147 TraceControlDialogFactory.getInstance().setCreateSessionDialog(new CreateSessionDialogStub());
148 TraceControlDialogFactory.getInstance().setGetEventInfoDialog(new GetEventInfoDialogStub());
149 TraceControlDialogFactory.getInstance().setConfirmDialog(new DestroyConfirmDialogStub());
150
151 // Initialize session handling scenario
152 fProxy.setScenario(TraceControlTestFacility.SCEN_SCENARIO_SESSION_HANDLING);
153
154 // ------------------------------------------------------------------------
155 // Create session
156 // ------------------------------------------------------------------------
157 TraceSessionComponent session = fFacility.createSession(groups[1]);
158
159 // Verify that session was created
160 assertNotNull(session);
161 assertEquals("mysession", session.getName());
162 assertEquals("/home/user/lttng-traces/mysession-20120314-132824", session.getSessionPath());
163 assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
164
165 // Initialize scenario
166 fProxy.setScenario(SCEN_SCENARIO3_TEST);
167
168 // ------------------------------------------------------------------------
169 // Create channel on session
170 // ------------------------------------------------------------------------
171 CreateChannelDialogStub channelStub = new CreateChannelDialogStub();
172 channelStub.setIsKernel(true);
173 TraceControlDialogFactory.getInstance().setCreateChannelDialog(channelStub);
174
175 fFacility.executeCommand(session, "createChannelOnSession");
176
177 // Verify that Kernel domain was created
178 ITraceControlComponent[] domains = session.getChildren();
179 assertNotNull(domains);
180 assertEquals(1, domains.length);
181
182 assertEquals("Kernel", domains[0].getName());
183
184 // Verify that channel was created with correct data
185 ITraceControlComponent[] channels = domains[0].getChildren();
186 assertNotNull(channels);
187 assertEquals(1, channels.length);
188
189 assertTrue(channels[0] instanceof TraceChannelComponent);
190 TraceChannelComponent channel = (TraceChannelComponent) channels[0];
191 assertEquals("mychannel", channel.getName());
192 assertEquals(4, channel.getNumberOfSubBuffers());
193 assertEquals("splice()", channel.getOutputType());
194 assertEquals(true, channel.isOverwriteMode());
195 assertEquals(200, channel.getReadTimer());
196 assertEquals(TraceEnablement.ENABLED, channel.getState());
197 assertEquals(16384, channel.getSubBufferSize());
198 assertEquals(100, channel.getSwitchTimer());
199
200 // ------------------------------------------------------------------------
201 // Create channel on domain
202 // ------------------------------------------------------------------------
203 ChannelInfo info = (ChannelInfo)channelStub.getChannelInfo();
204 info.setName("mychannel2");
205 info.setOverwriteMode(false);
206 info.setSubBufferSize(32768);
207 info.setNumberOfSubBuffers(2);
208 info.setSwitchTimer(100);
209 info.setReadTimer(200);
210 channelStub.setChannelInfo(info);
211
212 fFacility.executeCommand(domains[0], "createChannelOnDomain");
213
214 // Get Kernel domain component instance
215 domains = session.getChildren();
216 assertNotNull(domains);
217 assertEquals(1, domains.length);
218
219 // Verify that channel was created with correct data
220 channels = domains[0].getChildren();
221 assertNotNull(channels);
222 assertEquals(2, channels.length);
223
224 assertTrue(channels[1] instanceof TraceChannelComponent);
225 channel = (TraceChannelComponent) channels[1];
226 assertEquals("mychannel2", channel.getName());
227 assertEquals(2, channel.getNumberOfSubBuffers());
228 assertEquals("splice()", channel.getOutputType());
229 assertEquals(false, channel.isOverwriteMode());
230 assertEquals(200, channel.getReadTimer());
231 assertEquals(TraceEnablement.ENABLED, channel.getState());
232 assertEquals(32768, channel.getSubBufferSize());
233 assertEquals(100, channel.getSwitchTimer());
234
235 EnableEventsDialogStub eventsDialogStub = new EnableEventsDialogStub();
236 eventsDialogStub.setIsTracePoints(true);
237 List<String> events = new ArrayList<String>();
238 events.add("sched_kthread_stop");
239 events.add("sched_kthread_stop_ret");
240 eventsDialogStub.setNames(events);
241 eventsDialogStub.setIsKernel(true);
242 TraceControlDialogFactory.getInstance().setEnableEventsDialog(eventsDialogStub);
243
244 // ------------------------------------------------------------------------
245 // disable channels
246 // ------------------------------------------------------------------------
247 // Get Kernel domain component instance
248 domains = session.getChildren();
249 assertNotNull(domains);
250 assertEquals(1, domains.length);
251
252 // Verify that channel was created with correct data
253 channels = domains[0].getChildren();
254 assertNotNull(channels);
255 assertEquals(2, channels.length);
256
257 fFacility.executeCommand(channels, "disableChannel");
258
259 assertEquals(TraceEnablement.DISABLED, ((TraceChannelComponent)channels[0]).getState());
260 assertEquals(TraceEnablement.DISABLED, ((TraceChannelComponent)channels[1]).getState());
261
262 // ------------------------------------------------------------------------
263 // enable channels
264 // ------------------------------------------------------------------------
265 // Get Kernel domain component instance
266 domains = session.getChildren();
267 assertNotNull(domains);
268 assertEquals(1, domains.length);
269
270 // Verify that channel was created with correct data
271 channels = domains[0].getChildren();
272 assertNotNull(channels);
273 assertEquals(2, channels.length);
274
275 fFacility.executeCommand(channels, "enableChannel");
276
277 assertEquals(TraceEnablement.ENABLED, ((TraceChannelComponent)channels[0]).getState());
278 assertEquals(TraceEnablement.ENABLED, ((TraceChannelComponent)channels[1]).getState());
279
280 // ------------------------------------------------------------------------
281 // enable event (tracepoints) on session
282 // ------------------------------------------------------------------------
283 fFacility.executeCommand(session, "enableEventOnSession");
284
285 // Get Kernel domain component instance
286 domains = session.getChildren();
287 assertNotNull(domains);
288 assertEquals(1, domains.length);
289
290 // Verify that channel was created with correct data
291 channels = domains[0].getChildren();
292 assertNotNull(channels);
293 assertEquals(3, channels.length);
294
295 assertTrue(channels[2] instanceof TraceChannelComponent);
296 channel = (TraceChannelComponent) channels[2];
297 assertEquals("channel0", channel.getName());
298 // No need to check parameters of default channel because that has been done in other tests
299
300 ITraceControlComponent[] channel0Events = channel.getChildren();
301 assertEquals(2, channel0Events.length);
302
303 assertTrue(channel0Events[0] instanceof TraceEventComponent);
304 assertTrue(channel0Events[1] instanceof TraceEventComponent);
305
306 TraceEventComponent event = (TraceEventComponent) channel0Events[0];
307 assertEquals("sched_kthread_stop_ret", event.getName());
308 assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
309 assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
310 assertEquals(TraceEnablement.ENABLED, event.getState());
311
312 event = (TraceEventComponent) channel0Events[1];
313 assertEquals("sched_kthread_stop", event.getName());
314 assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
315 assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
316 assertEquals(TraceEnablement.ENABLED, event.getState());
317
318 // ------------------------------------------------------------------------
319 // enable event (tracepoints) on domain
320 // ------------------------------------------------------------------------
321 events.clear();
322 events.add("sched_wakeup_new");
323 eventsDialogStub.setNames(events);
324
325 fFacility.executeCommand(domains[0], "enableEventOnDomain");
326
327 // Get Kernel domain component instance
328 domains = session.getChildren();
329 assertNotNull(domains);
330 assertEquals(1, domains.length);
331
332 // Verify that channel was created with correct data
333 channels = domains[0].getChildren();
334 channel = (TraceChannelComponent) channels[2];
335 // No need to check parameters of default channel because that has been done in other tests
336
337 channel = (TraceChannelComponent) channels[2];
338
339 channel0Events = channel.getChildren();
340 assertEquals(3, channel0Events.length);
341
342 assertTrue(channel0Events[2] instanceof TraceEventComponent);
343
344 event = (TraceEventComponent) channel0Events[2];
345 assertEquals("sched_wakeup_new", event.getName());
346 assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
347 assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
348 assertEquals(TraceEnablement.ENABLED, event.getState());
349
350 // ------------------------------------------------------------------------
351 // enable event (tracepoints) on channel
352 // ------------------------------------------------------------------------
353 events.clear();
354 eventsDialogStub.setNames(events);
355 eventsDialogStub.setIsAllTracePoints(true);
356
357 fFacility.executeCommand(channels[1], "enableEventOnChannel");
358
359 // Get Kernel domain component instance
360 domains = session.getChildren();
361 assertNotNull(domains);
362 assertEquals(1, domains.length);
363
364 // Verify that channel was created with correct data
365 channels = domains[0].getChildren();
366 // No need to check parameters of default channel because that has been done in other tests
367 channel = (TraceChannelComponent) channels[1];
368
369 channel0Events = channel.getChildren();
370 assertEquals(3, channel0Events.length);
371
372 assertTrue(channel0Events[0] instanceof TraceEventComponent);
373 assertTrue(channel0Events[1] instanceof TraceEventComponent);
374 assertTrue(channel0Events[2] instanceof TraceEventComponent);
375
376 event = (TraceEventComponent) channel0Events[0];
377 assertEquals("sched_kthread_stop_ret", event.getName());
378 assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
379 assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
380 assertEquals(TraceEnablement.ENABLED, event.getState());
381
382 event = (TraceEventComponent) channel0Events[1];
383 assertEquals("sched_kthread_stop", event.getName());
384 assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
385 assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
386 assertEquals(TraceEnablement.ENABLED, event.getState());
387
388 event = (TraceEventComponent) channel0Events[2];
389 assertEquals("sched_wakeup_new", event.getName());
390 assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
391 assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
392 assertEquals(TraceEnablement.ENABLED, event.getState());
393
394 // ------------------------------------------------------------------------
395 // enable event (syscall) on channel
396 // ------------------------------------------------------------------------
397 events.clear();
398 eventsDialogStub.setIsTracePoints(false);
399 eventsDialogStub.setIsAllTracePoints(false);
400 eventsDialogStub.setIsSysCalls(true);
401
402 fFacility.executeCommand(channels[0], "enableEventOnChannel");
403
404 // Get Kernel domain component instance
405 domains = session.getChildren();
406 assertNotNull(domains);
407 assertEquals(1, domains.length);
408
409 // Verify that channel was created with correct data
410 channels = domains[0].getChildren();
411 channel = (TraceChannelComponent) channels[0];
412 // No need to check parameters of default channel because that has been done in other tests
413
414 channel = (TraceChannelComponent) channels[0];
415
416 channel0Events = channel.getChildren();
417 assertEquals(1, channel0Events.length);
418
419 assertTrue(channel0Events[0] instanceof TraceEventComponent);
420
421 event = (TraceEventComponent) channel0Events[0];
422 assertEquals("syscalls", event.getName());
423 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
424 assertEquals(TraceEventType.SYSCALL, event.getEventType());
425 assertEquals(TraceEnablement.ENABLED, event.getState());
426
427 // ------------------------------------------------------------------------
428 // enable event (syscall) on domain
429 // ------------------------------------------------------------------------
430 fFacility.executeCommand(domains[0], "enableEventOnDomain");
431
432 // Get Kernel domain component instance
433 domains = session.getChildren();
434 assertNotNull(domains);
435 assertEquals(1, domains.length);
436
437 // Verify that channel was created with correct data
438 channels = domains[0].getChildren();
439 channel = (TraceChannelComponent) channels[0];
440 // No need to check parameters of default channel because that has been done in other tests
441
442 channel = (TraceChannelComponent) channels[2];
443
444 channel0Events = channel.getChildren();
445 assertEquals(4, channel0Events.length);
446
447 assertTrue(channel0Events[0] instanceof TraceEventComponent);
448
449 event = (TraceEventComponent) channel0Events[0];
450 assertEquals("syscalls", event.getName());
451 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
452 assertEquals(TraceEventType.SYSCALL, event.getEventType());
453 assertEquals(TraceEnablement.ENABLED, event.getState());
454
455 // ------------------------------------------------------------------------
456 // enable event (syscall) on session
457 // ------------------------------------------------------------------------
458 fFacility.executeCommand(session, "enableEventOnSession");
459
460 // Get Kernel domain component instance
461 domains = session.getChildren();
462 assertNotNull(domains);
463 assertEquals(1, domains.length);
464
465 // Verify that channel was created with correct data
466 channels = domains[0].getChildren();
467 channel = (TraceChannelComponent) channels[0];
468 // No need to check parameters of default channel because that has been done in other tests
469
470 channel = (TraceChannelComponent) channels[2];
471
472 channel0Events = channel.getChildren();
473 assertEquals(4, channel0Events.length);
474
475 assertTrue(channel0Events[0] instanceof TraceEventComponent);
476
477 event = (TraceEventComponent) channel0Events[0];
478 assertEquals("syscalls", event.getName());
479 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
480 assertEquals(TraceEventType.SYSCALL, event.getEventType());
481 assertEquals(TraceEnablement.ENABLED, event.getState());
482
483
484 // ------------------------------------------------------------------------
485 // enable event (dynamic probe) on domain
486 // ------------------------------------------------------------------------
487 events.clear();
488 eventsDialogStub.setIsSysCalls(false);
489 eventsDialogStub.setIsDynamicProbe(true);
490 eventsDialogStub.setDynamicProbe("0xc0101280");
491 eventsDialogStub.setProbeEventName("myevent1");
492
493 fFacility.executeCommand(domains[0], "enableEventOnDomain");
494
495 // Get Kernel domain component instance
496 domains = session.getChildren();
497 assertNotNull(domains);
498 assertEquals(1, domains.length);
499
500 // Verify that channel was created with correct data
501 channels = domains[0].getChildren();
502 channel = (TraceChannelComponent) channels[2];
503 // No need to check parameters of default channel because that has been done in other tests
504
505 channel0Events = channel.getChildren();
506 assertEquals(5, channel0Events.length);
507
508 assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);
509
510 TraceProbeEventComponent probeEvent = (TraceProbeEventComponent) channel0Events[0];
511 assertEquals("myevent1", probeEvent.getName());
512 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
513 assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
514 assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
515 assertNull(probeEvent.getOffset());
516 assertEquals("0xc0101280", probeEvent.getAddress());
517 assertNull(probeEvent.getSymbol());
518
519 // ------------------------------------------------------------------------
520 // enable event (dynamic probe) on channel
521 // ------------------------------------------------------------------------
522 eventsDialogStub.setIsDynamicProbe(true);
523 eventsDialogStub.setDynamicProbe("init_post");
524 eventsDialogStub.setProbeEventName("myevent2");
525
526 fFacility.executeCommand(channels[2], "enableEventOnChannel");
527
528 // Get Kernel domain component instance
529 domains = session.getChildren();
530 assertNotNull(domains);
531 assertEquals(1, domains.length);
532
533 // Verify that channel was created with correct data
534 channels = domains[0].getChildren();
535 channel = (TraceChannelComponent) channels[2];
536 // No need to check parameters of default channel because that has been done in other tests
537
538 channel0Events = channel.getChildren();
539 assertEquals(6, channel0Events.length);
540
541 assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);
542
543 probeEvent = (TraceProbeEventComponent) channel0Events[0];
544 assertEquals("myevent2", probeEvent.getName());
545 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
546 assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
547 assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
548 assertEquals("0x0", probeEvent.getOffset());
549 assertNull(null, probeEvent.getAddress());
550 assertEquals("init_post", probeEvent.getSymbol());
551
552 // ------------------------------------------------------------------------
553 // enable event (dynamic probe) on session
554 // ------------------------------------------------------------------------
555 eventsDialogStub.setIsDynamicProbe(true);
556 eventsDialogStub.setDynamicProbe("init_post:0x1000");
557 eventsDialogStub.setProbeEventName("myevent3");
558
559 fFacility.executeCommand(session, "enableEventOnSession");
560
561 // Get Kernel domain component instance
562 domains = session.getChildren();
563 assertNotNull(domains);
564 assertEquals(1, domains.length);
565
566 // Verify that channel was created with correct data
567 channels = domains[0].getChildren();
568 channel = (TraceChannelComponent) channels[2];
569 // No need to check parameters of default channel because that has been done in other tests
570
571 channel0Events = channel.getChildren();
572 assertEquals(7, channel0Events.length);
573
574 assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);
575
576 probeEvent = (TraceProbeEventComponent) channel0Events[0];
577 assertEquals("myevent3", probeEvent.getName());
578 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
579 assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
580 assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
581 assertEquals("0x1000", probeEvent.getOffset());
582 assertNull(null, probeEvent.getAddress());
583 assertEquals("init_post", probeEvent.getSymbol());
584
585 // ------------------------------------------------------------------------
586 // enable event (dynamic function probe) on session
587 // ------------------------------------------------------------------------
588 eventsDialogStub.setIsDynamicProbe(false);
589 eventsDialogStub.setDynamicProbe(null);
590 eventsDialogStub.setProbeEventName(null);
591 eventsDialogStub.setIsFunctionProbe(true);
592 eventsDialogStub.setFunctionEventName("myevent4");
593 eventsDialogStub.setFunctionProbe("create_dev");
594
595 fFacility.executeCommand(session, "enableEventOnSession");
596
597 // Get Kernel domain component instance
598 domains = session.getChildren();
599 assertNotNull(domains);
600 assertEquals(1, domains.length);
601
602 // Verify that channel was created with correct data
603 channels = domains[0].getChildren();
604 channel = (TraceChannelComponent) channels[2];
605 // No need to check parameters of default channel because that has been done in other tests
606
607 channel0Events = channel.getChildren();
608 assertEquals(8, channel0Events.length);
609
610 assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);
611
612 probeEvent = (TraceProbeEventComponent) channel0Events[0];
613 assertEquals("myevent4", probeEvent.getName());
614 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
615 assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
616 assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
617 assertEquals("0x0", probeEvent.getOffset());
618 assertNull(null, probeEvent.getAddress());
619 assertEquals("create_dev", probeEvent.getSymbol());
620
621 // ------------------------------------------------------------------------
622 // enable event (dynamic function probe) on domain
623 // ------------------------------------------------------------------------
624 eventsDialogStub.setIsFunctionProbe(true);
625 eventsDialogStub.setFunctionEventName("myevent5");
626 eventsDialogStub.setFunctionProbe("create_dev:0x2000");
627
628 fFacility.executeCommand(domains[0], "enableEventOnDomain");
629
630 // Get Kernel domain component instance
631 domains = session.getChildren();
632 assertNotNull(domains);
633 assertEquals(1, domains.length);
634
635 // Verify that channel was created with correct data
636 channels = domains[0].getChildren();
637 channel = (TraceChannelComponent) channels[2];
638 // No need to check parameters of default channel because that has been done in other tests
639
640 channel0Events = channel.getChildren();
641 assertEquals(9, channel0Events.length);
642
643 assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);
644
645 probeEvent = (TraceProbeEventComponent) channel0Events[0];
646 assertEquals("myevent5", probeEvent.getName());
647 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
648 assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
649 assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
650 assertEquals("0x2000", probeEvent.getOffset());
651 assertNull(null, probeEvent.getAddress());
652 assertEquals("create_dev", probeEvent.getSymbol());
653
654 // ------------------------------------------------------------------------
655 // enable event (dynamic function probe) on channel
656 // ------------------------------------------------------------------------
657 eventsDialogStub.setIsFunctionProbe(true);
658 eventsDialogStub.setFunctionEventName("myevent");
659 eventsDialogStub.setFunctionProbe("create_dev:0x2000");
660
661 fFacility.executeCommand(channels[0], "enableEventOnChannel");
662
663 // Get Kernel domain component instance
664 domains = session.getChildren();
665 assertNotNull(domains);
666 assertEquals(1, domains.length);
667
668 // Verify that channel was created with correct data
669 channels = domains[0].getChildren();
670 channel = (TraceChannelComponent) channels[0];
671 // No need to check parameters of default channel because that has been done in other tests
672
673 channel0Events = channel.getChildren();
674 assertEquals(2, channel0Events.length);
675
676 assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);
677
678 probeEvent = (TraceProbeEventComponent) channel0Events[0];
679 assertEquals("myevent", probeEvent.getName());
680 assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
681 assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
682 assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
683 assertEquals("0x2000", probeEvent.getOffset());
684 assertNull(null, probeEvent.getAddress());
685 assertEquals("create_dev", probeEvent.getSymbol());
686
687 // ------------------------------------------------------------------------
688 // refresh
689 // ------------------------------------------------------------------------
690 fFacility.executeCommand(node, "refresh");
691 groups = node.getChildren();
692 assertNotNull(groups);
693 assertEquals(2, groups.length);
694 assertEquals(3, groups[0].getChildren().length); // provider
695 assertEquals(1, groups[1].getChildren().length); // sessions
696 assertEquals(1, groups[1].getChildren()[0].getChildren().length); // domains
697 assertEquals(3, groups[1].getChildren()[0].getChildren()[0].getChildren().length); // channels
698 assertEquals(2, groups[1].getChildren()[0].getChildren()[0].getChildren()[0].getChildren().length); // events (of channel[0])
699
700 // Initialize session handling scenario
701 fProxy.setScenario(TraceControlTestFacility.SCEN_SCENARIO_SESSION_HANDLING);
702
703 session = (TraceSessionComponent)groups[1].getChildren()[0];
704
705 // ------------------------------------------------------------------------
706 // start session
707 // ------------------------------------------------------------------------
708 fFacility.startSession(session);
709 assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
710
711 // ------------------------------------------------------------------------
712 // stop session
713 // ------------------------------------------------------------------------
714 fFacility.stopSession(session);
715 assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
716
717 // ------------------------------------------------------------------------
718 // Destroy session
719 // ------------------------------------------------------------------------
720
721 fFacility.destroySession(session);
722
723 // Verify that no more session components exist
724 assertEquals(0, groups[1].getChildren().length);
725
726 //-------------------------------------------------------------------------
727 // Disconnect node
728 //-------------------------------------------------------------------------
729 fFacility.executeCommand(node, "disconnect");
730 assertEquals(TargetNodeState.DISCONNECTED, node.getTargetNodeState());
731
732 //-------------------------------------------------------------------------
733 // Delete node
734 //-------------------------------------------------------------------------
735
736 fFacility.executeCommand(node, "delete");
737 assertEquals(0,fFacility.getControlView().getTraceControlRoot().getChildren().length);
738 }
739
740}
Tracecompass - Deliverables
This page took 0.071346 seconds and 5 git commands to generate.