1 /**********************************************************************
2 * Copyright (c) 2012 Ericsson
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
10 * Bernd Hufmann - Initial API and implementation
11 **********************************************************************/
12 package org
.eclipse
.linuxtools
.lttng2
.ui
.tests
.control
.model
.component
;
17 import junit
.framework
.Test
;
18 import junit
.framework
.TestCase
;
19 import junit
.framework
.TestSuite
;
21 import org
.eclipse
.core
.commands
.ExecutionException
;
22 import org
.eclipse
.core
.commands
.NotEnabledException
;
23 import org
.eclipse
.core
.commands
.NotHandledException
;
24 import org
.eclipse
.core
.commands
.common
.NotDefinedException
;
25 import org
.eclipse
.core
.runtime
.FileLocator
;
26 import org
.eclipse
.core
.runtime
.Path
;
27 import org
.eclipse
.linuxtools
.internal
.lttng2
.stubs
.service
.TestRemoteSystemProxy
;
28 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.dialogs
.IConfirmDialog
;
29 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.dialogs
.ICreateChannelOnSessionDialog
;
30 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.dialogs
.ICreateSessionDialog
;
31 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.dialogs
.IGetEventInfoDialog
;
32 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.dialogs
.TraceControlDialogFactory
;
33 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.IChannelInfo
;
34 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.ITraceControlComponent
;
35 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.TargetNodeState
;
36 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.TraceEnablement
;
37 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.TraceEventType
;
38 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.TraceLogLevel
;
39 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.TraceSessionState
;
40 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.BaseEventComponent
;
41 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.ChannelInfo
;
42 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.KernelProviderComponent
;
43 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.TargetNodeComponent
;
44 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.TraceChannelComponent
;
45 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.TraceDomainComponent
;
46 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.TraceEventComponent
;
47 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.TraceSessionComponent
;
48 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.TraceSessionGroup
;
49 import org
.eclipse
.linuxtools
.internal
.lttng2
.ui
.views
.control
.model
.impl
.UstProviderComponent
;
50 import org
.eclipse
.linuxtools
.lttng2
.ui
.tests
.Activator
;
51 import org
.eclipse
.rse
.core
.model
.Host
;
52 import org
.eclipse
.rse
.core
.model
.IHost
;
53 import org
.eclipse
.rse
.internal
.core
.model
.SystemProfile
;
54 import org
.eclipse
.swt
.widgets
.Shell
;
55 import org
.junit
.After
;
56 import org
.junit
.Before
;
59 * The class <code>TraceControlTreeModelTest</code> contains tests for the tree component classes.
61 @SuppressWarnings("nls")
62 public class TraceControlProviderTests
extends TestCase
{
64 private static final String DIRECTORY
= "testfiles";
65 private static final String TEST_STREAM
= "CreateTreeTest.cfg";
66 private static final String SCEN_INIT_TEST
= "Initialize";
67 private static final String SCEN_SCENARIO1_TEST
= "Scenario1";
68 private static final String SCEN_SCENARIO2_TEST
= "Scenario2";
70 // ------------------------------------------------------------------------
72 // ------------------------------------------------------------------------
73 private TraceControlTestFacility fFacility
;
74 private TestRemoteSystemProxy fProxy
;
75 private String fTestFile
;
77 // ------------------------------------------------------------------------
79 // ------------------------------------------------------------------------
82 * Returns test setup used when executing test case stand-alone.
83 * @return Test setup class
85 public static Test
suite() {
86 return new ModelImplTestSetup(new TestSuite(TraceControlProviderTests
.class));
89 // ------------------------------------------------------------------------
91 // ------------------------------------------------------------------------
94 * Perform pre-test initialization.
97 * if the initialization fails for some reason
102 public void setUp() throws Exception
{
103 fFacility
= TraceControlTestFacility
.getInstance();
104 fProxy
= new TestRemoteSystemProxy();
105 URL location
= FileLocator
.find(Activator
.getDefault().getBundle(), new Path(DIRECTORY
+ File
.separator
+ TEST_STREAM
), null);
106 File testfile
= new File(FileLocator
.toFileURL(location
).toURI());
107 fTestFile
= testfile
.getAbsolutePath();
111 * Perform post-test clean-up.
114 * if the clean-up fails for some reason
119 public void tearDown() throws Exception
{
123 * Run the TraceControlComponent.
125 public void testTraceControlComponents()
128 fProxy
.setTestFile(fTestFile
);
129 fProxy
.setScenario(SCEN_INIT_TEST
);
131 ITraceControlComponent root
= TraceControlTestFacility
.getInstance().getControlView().getTraceControlRoot();
133 @SuppressWarnings("restriction")
134 IHost host
= new Host(new SystemProfile("myProfile", true));
135 host
.setHostName("127.0.0.1");
137 TargetNodeComponent node
= new TargetNodeComponent("myNode", root
, host
, fProxy
);
142 fFacility
.waitForJobs();
144 // Verify that node is connected
145 assertEquals(TargetNodeState
.CONNECTED
, node
.getTargetNodeState());
147 // Get provider groups
148 ITraceControlComponent
[] groups
= node
.getChildren();
149 assertNotNull(groups
);
150 assertEquals(2, groups
.length
);
152 // Get kernel provider
153 ITraceControlComponent
[] providers
= groups
[0].getChildren();
154 KernelProviderComponent kernelProvider
= (KernelProviderComponent
) providers
[0];
156 // Get kernel provider events and select 2 events
157 ITraceControlComponent
[] events
= kernelProvider
.getChildren();
158 assertNotNull(events
);
159 assertEquals(3, events
.length
);
161 BaseEventComponent baseEventInfo0
= (BaseEventComponent
) events
[0];
162 BaseEventComponent baseEventInfo1
= (BaseEventComponent
) events
[1];
164 // Initialize dialog implementations for command execution
165 TraceControlDialogFactory
.getInstance().setCreateSessionDialog(new CreateSessionDialogStub());
166 TraceControlDialogFactory
.getInstance().setGetEventInfoDialog(new GetEventInfoDialogStub());
167 TraceControlDialogFactory
.getInstance().setConfirmDialog(new DestroyConfirmDialogStub());
169 // Initialize scenario
170 fProxy
.setScenario(SCEN_SCENARIO1_TEST
);
172 // ------------------------------------------------------------------------
174 // ------------------------------------------------------------------------
175 TraceSessionComponent session
= createSession(groups
[1]);
177 // Verify that session was created
178 assertNotNull(session
);
179 assertEquals("mysession", session
.getName());
180 assertEquals("/home/user/lttng-traces/mysession-20120314-132824", session
.getSessionPath());
181 assertEquals(TraceSessionState
.INACTIVE
, session
.getSessionState());
183 // ------------------------------------------------------------------------
184 // Enable event on default channel on created session above
185 // ------------------------------------------------------------------------
186 ITraceControlComponent
[] components
= { baseEventInfo0
, baseEventInfo1
};
188 fFacility
.getControlView().setSelection(components
);
189 // Give GUI time to actually execute refresh
190 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
192 fFacility
.executeCommand("assign.event");
193 fFacility
.waitForJobs();
195 // Verify that kernel domain was created
196 ITraceControlComponent
[] domains
= session
.getChildren();
197 assertNotNull(domains
);
198 assertEquals(1, domains
.length
);
200 assertEquals("Kernel", domains
[0].getName());
202 // Verify that channel0 was created with default values
203 ITraceControlComponent
[] channels
= domains
[0].getChildren();
204 assertNotNull(channels
);
205 assertEquals(1, channels
.length
);
207 assertTrue(channels
[0] instanceof TraceChannelComponent
);
208 TraceChannelComponent channel
= (TraceChannelComponent
) channels
[0];
209 assertEquals("channel0", channel
.getName());
210 assertEquals(4, channel
.getNumberOfSubBuffers());
211 assertEquals("splice()", channel
.getOutputType());
212 assertEquals(false, channel
.isOverwriteMode());
213 assertEquals(200, channel
.getReadTimer());
214 assertEquals(TraceEnablement
.ENABLED
, channel
.getState());
215 assertEquals(262144, channel
.getSubBufferSize());
216 assertEquals(0, channel
.getSwitchTimer());
218 // Verify that event components were created
219 ITraceControlComponent
[] channel0Events
= channel
.getChildren();
220 assertNotNull(channel0Events
);
221 assertEquals(2, channel0Events
.length
);
222 assertTrue(channel0Events
[0] instanceof TraceEventComponent
);
223 assertTrue(channel0Events
[1] instanceof TraceEventComponent
);
225 TraceEventComponent event
= (TraceEventComponent
) channel0Events
[0];
226 assertEquals("sched_kthread_stop_ret", event
.getName());
227 assertEquals(TraceLogLevel
.TRACE_EMERG
, event
.getLogLevel());
228 assertEquals(TraceEventType
.TRACEPOINT
, event
.getEventType());
229 assertEquals(TraceEnablement
.ENABLED
, event
.getState());
231 TraceEventComponent event1
= (TraceEventComponent
) channel0Events
[1];
232 assertEquals("sched_kthread_stop", event1
.getName());
233 assertEquals(TraceLogLevel
.TRACE_EMERG
, event1
.getLogLevel());
234 assertEquals(TraceEventType
.TRACEPOINT
, event1
.getEventType());
235 assertEquals(TraceEnablement
.ENABLED
, event1
.getState());
237 // ------------------------------------------------------------------------
238 // Disable event components
239 // ------------------------------------------------------------------------
240 ITraceControlComponent
[] selection
= { event
, event1
};
241 fFacility
.getControlView().setSelection(selection
);
242 // Give GUI time to actually execute the selection
243 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
244 fFacility
.executeCommand("disable.event");
245 fFacility
.waitForJobs();
247 assertEquals(TraceEnablement
.DISABLED
, event
.getState());
248 assertEquals(TraceEnablement
.DISABLED
, event1
.getState());
250 // ------------------------------------------------------------------------
251 // Enable event component
252 // ------------------------------------------------------------------------
253 fFacility
.getControlView().setSelection(event1
);
254 fFacility
.executeCommand("enable.event");
255 fFacility
.waitForJobs();
257 // Verify event state
258 assertEquals(TraceEnablement
.ENABLED
, event1
.getState());
260 // ------------------------------------------------------------------------
262 // ------------------------------------------------------------------------
263 destroySession(session
);
265 // Verify that no more session components exist
266 assertEquals(0, groups
[1].getChildren().length
);
269 // ------------------------------------------------------------------------
271 // ------------------------------------------------------------------------
272 fProxy
.setScenario(SCEN_SCENARIO2_TEST
);
274 CreateSessionDialogStub sessionDialogStub
= new CreateSessionDialogStub();
275 sessionDialogStub
.setSessionPath("/home/user/temp");
276 TraceControlDialogFactory
.getInstance().setCreateSessionDialog(sessionDialogStub
);
278 session
= createSession(groups
[1]);
280 // Verify that session was created
281 assertNotNull(session
);
282 assertEquals("mysession", session
.getName());
283 assertEquals("/home/user/temp", session
.getSessionPath());
284 assertEquals(TraceSessionState
.INACTIVE
, session
.getSessionState());
286 // ------------------------------------------------------------------------
287 // Create Channel on UST global domain
288 // ------------------------------------------------------------------------
289 TraceControlDialogFactory
.getInstance().setCreateChannelOnSessionDialog(new CreateChannelOnSessionDialogStub());
291 fFacility
.getControlView().setSelection(session
);
292 // Give GUI time to actually execute refresh
293 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
295 fFacility
.executeCommand("createChannelOnSession");
296 fFacility
.waitForJobs();
298 // Verify that UST domain was created
299 domains
= session
.getChildren();
300 assertNotNull(domains
);
301 assertEquals(1, domains
.length
);
303 assertEquals("UST global", domains
[0].getName());
305 // Verify that channel was created with correct data
306 channels
= domains
[0].getChildren();
307 assertNotNull(channels
);
308 assertEquals(1, channels
.length
);
310 assertTrue(channels
[0] instanceof TraceChannelComponent
);
311 channel
= (TraceChannelComponent
) channels
[0];
312 assertEquals("mychannel", channel
.getName());
313 assertEquals(2, channel
.getNumberOfSubBuffers());
314 assertEquals("mmap()", channel
.getOutputType());
315 assertEquals(false, channel
.isOverwriteMode());
316 assertEquals(100, channel
.getReadTimer());
317 assertEquals(TraceEnablement
.ENABLED
, channel
.getState());
318 assertEquals(16384, channel
.getSubBufferSize());
319 assertEquals(200, channel
.getSwitchTimer());
321 // ------------------------------------------------------------------------
322 // Enable event on default channel on created session above
323 // ------------------------------------------------------------------------
324 // Get first UST provider
325 UstProviderComponent ustProvider
= (UstProviderComponent
) providers
[1];
326 assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", ustProvider
.getName());
327 assertEquals(9379, ustProvider
.getPid());
330 events
= ustProvider
.getChildren();
331 assertNotNull(events
);
332 assertEquals(2, events
.length
);
334 baseEventInfo0
= (BaseEventComponent
) events
[0];
335 baseEventInfo1
= (BaseEventComponent
) events
[1];
337 ITraceControlComponent
[] ustSelection
= { baseEventInfo0
, baseEventInfo1
};
339 fFacility
.getControlView().setSelection(ustSelection
);
340 // Give GUI time to actually execute refresh
341 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
342 fFacility
.executeCommand("assign.event");
343 fFacility
.waitForJobs();
345 // verify that events were created under the channel
346 // Note that domain and channel has to be re-read because the tree is re-created
348 domains
= session
.getChildren();
350 // Verify that channel was created with correct data
351 channels
= domains
[0].getChildren();
353 ITraceControlComponent
[] ustEvents
= channels
[0].getChildren();
354 assertEquals(2, ustEvents
.length
);
356 event
= (TraceEventComponent
) ustEvents
[0];
357 assertEquals("ust_tests_hello:tptest_sighandler", event
.getName());
358 assertEquals(TraceLogLevel
.TRACE_DEBUG_LINE
, event
.getLogLevel());
359 assertEquals(TraceEventType
.TRACEPOINT
, event
.getEventType());
360 assertEquals(TraceEnablement
.ENABLED
, event
.getState());
362 event
= (TraceEventComponent
) ustEvents
[1];
363 assertEquals("ust_tests_hello:tptest", ustEvents
[1].getName());
364 assertEquals(TraceLogLevel
.TRACE_DEBUG_LINE
, event
.getLogLevel());
365 assertEquals(TraceEventType
.TRACEPOINT
, event
.getEventType());
366 assertEquals(TraceEnablement
.ENABLED
, event
.getState());
368 // ------------------------------------------------------------------------
369 // Disable event components
370 // ------------------------------------------------------------------------
371 fFacility
.getControlView().setSelection(event
);
372 // Give GUI time to actually execute the selection
373 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
374 fFacility
.executeCommand("disable.event");
375 fFacility
.waitForJobs();
377 assertEquals(TraceEnablement
.DISABLED
, event
.getState());
379 // ------------------------------------------------------------------------
380 // Enable event component
381 // ------------------------------------------------------------------------
382 fFacility
.getControlView().setSelection(event
);
383 fFacility
.executeCommand("enable.event");
384 fFacility
.waitForJobs();
386 // Verify event state
387 assertEquals(TraceEnablement
.ENABLED
, event
.getState());
389 // ------------------------------------------------------------------------
391 // ------------------------------------------------------------------------
392 destroySession(session
);
394 // Verify that no more session components exist
395 assertEquals(0, groups
[1].getChildren().length
);
398 // fFacility.delay(60000);
401 private TraceSessionComponent
createSession(ITraceControlComponent group
) throws ExecutionException
, NotDefinedException
, NotEnabledException
, NotHandledException
{
402 fFacility
.getControlView().setSelection(group
);
403 // Give GUI time to actually execute the selection
404 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
405 fFacility
.executeCommand("createSession");
406 fFacility
.waitForJobs();
408 ITraceControlComponent
[] sessions
= group
.getChildren();
409 if ((sessions
== null) || (sessions
.length
== 0)) {
412 return (TraceSessionComponent
)sessions
[0];
415 private void destroySession(TraceSessionComponent session
) throws ExecutionException
, NotDefinedException
, NotEnabledException
, NotHandledException
{
416 fFacility
.getControlView().setSelection(session
);
417 // Give GUI time to actually execute the selection
418 fFacility
.delay(TraceControlTestFacility
.GUI_REFESH_DELAY
);
419 fFacility
.executeCommand("destroySession");
420 fFacility
.waitForJobs();
423 // assertEquals("sched_kthread_stop_ret", baseEventInfo.getName());
424 // assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
425 // assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
427 // baseEventInfo = (BaseEventComponent) events[2];
428 // assertEquals("sched_wakeup_new", baseEventInfo.getName());
429 // assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
430 // assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
432 // // ------------------------------------------------------------------------
433 // // Verify UstProviderComponent
434 // // ------------------------------------------------------------------------
435 // UstProviderComponent ustProvider = (UstProviderComponent) providers[1];
436 // assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", ustProvider.getName());
437 // assertEquals(9379, ustProvider.getPid());
439 // // ------------------------------------------------------------------------
440 // // Verify event info (UST provider)
441 // // ------------------------------------------------------------------------
442 // events = ustProvider.getChildren();
443 // assertNotNull(events);
444 // assertEquals(2, events.length);
446 // baseEventInfo = (BaseEventComponent) events[0];
447 // assertNotNull(baseEventInfo);
448 // assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
449 // assertEquals(TraceLogLevel.TRACE_DEBUG_MODULE, baseEventInfo.getLogLevel());
450 // assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
452 // baseEventInfo = (BaseEventComponent) events[1];
453 // assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
454 // assertEquals(TraceLogLevel.TRACE_INFO, baseEventInfo.getLogLevel());
455 // assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
457 // // ------------------------------------------------------------------------
458 // // Verify UstProviderComponent
459 // // ------------------------------------------------------------------------
460 // ustProvider = (UstProviderComponent) providers[2];
461 // assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", ustProvider.getName());
462 // assertEquals(4852, ustProvider.getPid());
464 // // verify getters and setter
465 // verifyUstProviderGettersSetters(ustProvider);
467 // // ------------------------------------------------------------------------
468 // // Verify event info (UST provider)
469 // // ------------------------------------------------------------------------
470 // events = ustProvider.getChildren();
471 // assertNotNull(events);
472 // assertEquals(2, events.length);
474 // baseEventInfo = (BaseEventComponent) events[0];
475 // assertNotNull(baseEventInfo);
476 // assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
477 // assertEquals(TraceLogLevel.TRACE_WARNING, baseEventInfo.getLogLevel());
478 // assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
480 // baseEventInfo = (BaseEventComponent) events[1];
481 // assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
482 // assertEquals(TraceLogLevel.TRACE_DEBUG_FUNCTION, baseEventInfo.getLogLevel());
483 // assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
485 // // verify getters and setters
486 // verifyBaseEventGettersSetters(baseEventInfo);
488 // // ------------------------------------------------------------------------
489 // // Verify TraceSessionGroup
490 // // ------------------------------------------------------------------------
491 // ITraceControlComponent[] sessions = groups[1].getChildren();
492 // assertNotNull(sessions);
493 // assertEquals(2, sessions.length);
494 // for (int i = 0; i < sessions.length; i++) {
495 // assertTrue(sessions[i] instanceof TraceSessionComponent);
497 // assertEquals("mysession1", sessions[0].getName());
498 // assertEquals("mysession", sessions[1].getName());
500 // // ------------------------------------------------------------------------
501 // // Verify TraceSessionComponent
502 // // ------------------------------------------------------------------------
503 // TraceSessionComponent session = (TraceSessionComponent)sessions[1];
504 // assertEquals("mysession", session.getName());
505 // assertEquals("/home/user/lttng-traces/mysession-20120129-084256", session.getSessionPath());
506 // assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
508 // // Verify setters and setters
509 // verifySessionGetterSetters(session);
511 // ITraceControlComponent[] domains = session.getChildren();
512 // assertNotNull(domains);
513 // assertEquals(2, domains.length);
515 // // ------------------------------------------------------------------------
516 // // Verify Kernel domain
517 // // ------------------------------------------------------------------------
518 // assertEquals("Kernel", domains[0].getName());
519 // ITraceControlComponent[] channels = domains[0].getChildren();
520 // assertNotNull(channels);
521 // assertEquals(2, channels.length);
523 // // ------------------------------------------------------------------------
524 // // Verify Kernel's channel0
525 // // ------------------------------------------------------------------------
526 // assertTrue(channels[0] instanceof TraceChannelComponent);
527 // TraceChannelComponent channel = (TraceChannelComponent) channels[0];
528 // assertEquals("channel0", channel.getName());
529 // assertEquals(4, channel.getNumberOfSubBuffers());
530 // assertEquals("splice()", channel.getOutputType());
531 // assertEquals(false, channel.isOverwriteMode());
532 // assertEquals(200, channel.getReadTimer());
533 // assertEquals(TraceEnablement.ENABLED, channel.getState());
534 // assertEquals(262144, channel.getSubBufferSize());
535 // assertEquals(0, channel.getSwitchTimer());
537 // // ------------------------------------------------------------------------
538 // // Verify event info (kernel, channel0)
539 // // ------------------------------------------------------------------------
540 // ITraceControlComponent[] channel0Events = channel.getChildren();
541 // assertNotNull(channel0Events);
542 // assertEquals(5, channel0Events.length);
543 // assertTrue(channel0Events[0] instanceof TraceEventComponent);
544 // assertTrue(channel0Events[1] instanceof TraceEventComponent);
545 // assertTrue(channel0Events[2] instanceof TraceProbeEventComponent);
546 // assertTrue(channel0Events[3] instanceof TraceProbeEventComponent);
547 // assertTrue(channel0Events[4] instanceof TraceEventComponent);
549 // TraceEventComponent event = (TraceEventComponent) channel0Events[0];
550 // assertEquals("block_rq_remap", event.getName());
551 // assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
552 // assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
553 // assertEquals(TraceEnablement.ENABLED, event.getState());
555 // event = (TraceEventComponent) channel0Events[1];
556 // assertEquals("block_bio_remap", event.getName());
557 // assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
558 // assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
559 // assertEquals(TraceEnablement.DISABLED, event.getState());
561 // TraceProbeEventComponent probeEvent = (TraceProbeEventComponent) channel0Events[2];
562 // assertEquals("myevent2", probeEvent.getName());
563 // assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
564 // assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
565 // assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
566 // assertEquals("0xc0101340", probeEvent.getAddress());
567 // assertNull(probeEvent.getOffset());
568 // assertNull(probeEvent.getSymbol());
570 // probeEvent = (TraceProbeEventComponent) channel0Events[3];
571 // assertEquals("myevent0", probeEvent.getName());
572 // assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
573 // assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
574 // assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
575 // assertNull(probeEvent.getAddress());
576 // assertEquals("0x0", probeEvent.getOffset());
577 // assertEquals("init_post", probeEvent.getSymbol());
579 // event = (TraceEventComponent) channel0Events[4];
580 // assertEquals("syscalls", event.getName());
581 // assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
582 // assertEquals(TraceEventType.SYSCALL, event.getEventType());
583 // assertEquals(TraceEnablement.ENABLED, event.getState());
585 // // ------------------------------------------------------------------------
586 // // Verify Kernel's channel1
587 // // ------------------------------------------------------------------------
588 // assertEquals("channel1", channels[1].getName());
589 // channel = (TraceChannelComponent) channels[1];
590 // assertEquals(4, channel.getNumberOfSubBuffers());
591 // assertEquals("splice()", channel.getOutputType());
592 // assertEquals(true, channel.isOverwriteMode());
593 // assertEquals(400, channel.getReadTimer());
594 // assertEquals(TraceEnablement.DISABLED, channel.getState());
595 // assertEquals(524288, channel.getSubBufferSize());
596 // assertEquals(100, channel.getSwitchTimer());
598 // // ------------------------------------------------------------------------
599 // // Verify event info (kernel, channel1)
600 // // ------------------------------------------------------------------------
601 // ITraceControlComponent[] channel1Events = channels[1].getChildren();
602 // assertEquals(0, channel1Events.length);
604 // // ------------------------------------------------------------------------
605 // // Verify domain UST global
606 // // ------------------------------------------------------------------------
607 // assertEquals("UST global", domains[1].getName());
609 // ITraceControlComponent[] ustChannels = domains[1].getChildren();
611 // for (int i = 0; i < ustChannels.length; i++) {
612 // assertTrue(ustChannels[i] instanceof TraceChannelComponent);
615 // // ------------------------------------------------------------------------
616 // // Verify UST global's mychannel1
617 // // ------------------------------------------------------------------------
618 // channel = (TraceChannelComponent) ustChannels[0];
619 // assertEquals("mychannel1", channel.getName());
620 // assertEquals(8, channel.getNumberOfSubBuffers());
621 // assertEquals("mmap()", channel.getOutputType());
622 // assertEquals(true, channel.isOverwriteMode());
623 // assertEquals(100, channel.getReadTimer());
624 // assertEquals(TraceEnablement.DISABLED, channel.getState());
625 // assertEquals(8192, channel.getSubBufferSize());
626 // assertEquals(200, channel.getSwitchTimer());
628 // // verify getters and setters
629 // verifyChannelGettersSetters(channel);
631 // // ------------------------------------------------------------------------
632 // // Verify event info (UST global, mychannel1)
633 // // ------------------------------------------------------------------------
634 // ITraceControlComponent[] ustEvents = channel.getChildren();
635 // assertEquals(0, ustEvents.length);
637 // // ------------------------------------------------------------------------
638 // // Verify UST global's channel0
639 // // ------------------------------------------------------------------------
640 // channel = (TraceChannelComponent) ustChannels[1];
641 // assertEquals("channel0", channel.getName());
642 // assertEquals(4, channel.getNumberOfSubBuffers());
643 // assertEquals("mmap()", channel.getOutputType());
644 // assertEquals(false, channel.isOverwriteMode());
645 // assertEquals(200, channel.getReadTimer());
646 // assertEquals(TraceEnablement.ENABLED, channel.getState());
647 // assertEquals(4096, channel.getSubBufferSize());
648 // assertEquals(0, channel.getSwitchTimer());
650 // // ------------------------------------------------------------------------
651 // // Verify event info (UST global, channel0)
652 // // ------------------------------------------------------------------------
653 // ustEvents = channel.getChildren();
654 // assertEquals(2, ustEvents.length);
656 // event = (TraceEventComponent) ustEvents[0];
657 // assertEquals("ust_tests_hello:tptest_sighandler", event.getName());
658 // assertEquals(TraceLogLevel.TRACE_DEBUG_LINE, event.getLogLevel());
659 // assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
660 // assertEquals(TraceEnablement.DISABLED, event.getState());
662 // event = (TraceEventComponent) ustEvents[1];
663 // assertEquals("*", ustEvents[1].getName());
664 // assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
665 // assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
666 // assertEquals(TraceEnablement.ENABLED, event.getState());
668 // // verify getters and setters
669 // verifyEventGettersSetters(event);
672 // node.disconnect();
673 // assertEquals(TargetNodeState.DISCONNECTED, node.getTargetNodeState());
674 // assertNotNull(node.getImage());
675 // assertNotSame(connectedImage, node.getImage());
678 // private void verifySessionGetterSetters(TraceSessionComponent session) {
679 // // save original values
680 // String name = session.getName();
681 // String origPath = session.getSessionPath();
682 // TraceSessionState origState = session.getSessionState();
685 // session.setName("newName");
686 // assertEquals("newName", session.getName());
688 // session.setSessionPath("/home/user/tmp");
689 // assertEquals("/home/user/tmp", session.getSessionPath());
691 // session.setSessionState(TraceSessionState.INACTIVE);
692 // assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
693 // Image inactiveImage = session.getImage();
694 // assertNotNull(inactiveImage);
696 // session.setSessionState("active");
697 // assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
699 // Image activeImage = session.getImage();
700 // assertNotNull(activeImage);
701 // assertNotSame(activeImage, inactiveImage);
704 // // restore original values
705 // session.setName(name);
706 // session.setSessionPath(origPath);
707 // session.setSessionState(origState);
710 // private void verifyBaseEventGettersSetters(BaseEventComponent event) {
711 // // save original values
712 // String name = event.getName();
713 // TraceLogLevel level = event.getLogLevel();
714 // TraceEventType type = event.getEventType();
717 // event.setName("newName");
718 // assertEquals("newName", event.getName());
720 // event.setLogLevel(TraceLogLevel.TRACE_INFO);
721 // assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
722 // event.setLogLevel("TRACE_ALERT");
723 // assertEquals(TraceLogLevel.TRACE_ALERT, event.getLogLevel());
725 // event.setEventType(TraceEventType.UNKNOWN);
726 // assertEquals(TraceEventType.UNKNOWN, event.getEventType());
727 // event.setEventType("tracepoint");
728 // assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
730 // // restore original values
731 // event.setName(name);
732 // event.setLogLevel(level);
733 // event.setEventType(type);
736 // private void verifyEventGettersSetters(TraceEventComponent event) {
737 // // save original values
738 // String name = event.getName();
739 // TraceLogLevel level = event.getLogLevel();
740 // TraceEventType type = event.getEventType();
741 // TraceEnablement state = event.getState();
744 // event.setName("newName");
745 // assertEquals("newName", event.getName());
747 // event.setLogLevel(TraceLogLevel.TRACE_INFO);
748 // assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
749 // event.setLogLevel("TRACE_ALERT");
750 // assertEquals(TraceLogLevel.TRACE_ALERT, event.getLogLevel());
752 // event.setEventType(TraceEventType.UNKNOWN);
753 // assertEquals(TraceEventType.UNKNOWN, event.getEventType());
754 // event.setEventType("tracepoint");
755 // assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
757 // event.setState("disabled");
758 // assertEquals(TraceEnablement.DISABLED, event.getState());
760 // Image disabledImage = event.getImage();
761 // assertNotNull(disabledImage);
763 // event.setState(TraceEnablement.ENABLED);
764 // assertEquals(TraceEnablement.ENABLED, event.getState());
766 // Image enabledImage = event.getImage();
767 // assertNotNull(enabledImage);
768 // assertNotSame(enabledImage, disabledImage);
770 // // restore original values
771 // event.setName(name);
772 // event.setLogLevel(level);
773 // event.setEventType(type);
774 // event.setState(state);
777 // private void verifyChannelGettersSetters(TraceChannelComponent channel) {
778 // // save original values
779 // String name = channel.getName();
780 // int nbSubBuffers = channel.getNumberOfSubBuffers();
781 // String type = channel.getOutputType();
782 // boolean mode = channel.isOverwriteMode();
783 // long readTimer = channel.getReadTimer();
784 // TraceEnablement state = channel.getState();
785 // long subBufferSize = channel.getSubBufferSize();
786 // long switchTimer = channel.getSwitchTimer();
789 // channel.setName("newName");
790 // assertEquals("newName", channel.getName());
792 // channel.setNumberOfSubBuffers(2);
793 // assertEquals(2, channel.getNumberOfSubBuffers());
795 // channel.setOutputType("splice()");
796 // assertEquals("splice()", channel.getOutputType());
798 // channel.setOverwriteMode(false);
799 // assertEquals(false, channel.isOverwriteMode());
801 // channel.setReadTimer(250);
802 // assertEquals(250, channel.getReadTimer());
804 // channel.setState("enabled");
805 // assertEquals(TraceEnablement.ENABLED, channel.getState());
807 // Image enabledImage = channel.getImage();
808 // assertNotNull(enabledImage);
809 // channel.setState(TraceEnablement.DISABLED);
810 // assertEquals(TraceEnablement.DISABLED, channel.getState());
812 // Image disabledImage = channel.getImage();
813 // assertNotNull(disabledImage);
814 // assertNotSame(enabledImage, disabledImage);
816 // channel.setSubBufferSize(1024);
817 // assertEquals(1024, channel.getSubBufferSize());
819 // channel.setSwitchTimer(1000);
820 // assertEquals(1000, channel.getSwitchTimer());
822 // // restore original values
823 // channel.setName(name);
824 // channel.setNumberOfSubBuffers(nbSubBuffers);
825 // channel.setOutputType(type);
826 // channel.setOverwriteMode(mode);
827 // channel.setReadTimer(readTimer);
828 // channel.setState(state);
829 // channel.setSubBufferSize(subBufferSize);
830 // channel.setSwitchTimer(switchTimer);
833 // private void verifyUstProviderGettersSetters(UstProviderComponent ustProvider) {
834 // // save original values
835 // String name = ustProvider.getName();
836 // int pid = ustProvider.getPid();
839 // ustProvider.setName("newName");
840 // assertEquals("newName", ustProvider.getName());
842 // ustProvider.setPid(9876);
843 // assertEquals(9876, ustProvider.getPid());
845 // // restore original values
846 // ustProvider.setName(name);
847 // ustProvider.setPid(pid);
850 public class CreateSessionDialogStub
implements ICreateSessionDialog
{
851 public String fPath
= null;
854 public String
getSessionName() {
859 public String
getSessionPath() {
864 public boolean isDefaultSessionPath() {
865 return fPath
== null;
869 public void setTraceSessionGroup(TraceSessionGroup group
) {
878 public void setSessionPath(String path
) {
883 public class GetEventInfoDialogStub
implements IGetEventInfoDialog
{
885 private TraceSessionComponent
[] fSessions
;
888 public TraceSessionComponent
getSession() {
893 public TraceChannelComponent
getChannel() {
898 public void setIsKernel(boolean isKernel
) {
902 public void setSessions(TraceSessionComponent
[] sessions
) {
903 fSessions
= sessions
;
912 public class DestroyConfirmDialogStub
implements IConfirmDialog
{
915 public boolean openConfirm(Shell parent
, String title
, String message
) {
920 public class CreateChannelOnSessionDialogStub
implements ICreateChannelOnSessionDialog
{
923 public IChannelInfo
getChannelInfo() {
924 ChannelInfo info
= new ChannelInfo("mychannel");
925 info
.setNumberOfSubBuffers(2);
926 info
.setOverwriteMode(false);
927 info
.setReadTimer(100);
928 info
.setSwitchTimer(200);
929 info
.setSubBufferSize(16384);
934 public void setDomainComponent(TraceDomainComponent domain
) {
943 public boolean isKernel() {