~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

URL location = FileLocator.find(FrameworkUtil.getBundle(this.getClass()), new Path(TraceControlTestFacility.DIRECTORY + File.separator + TEST_STREAM), null);

103

File testfile = new File(FileLocator.toFileURL(location).toURI());

104

fTestFile = testfile.getAbsolutePath();

105

}

106

107

/**

108

* Perform post-test clean-up.

109

110

* @throws Exception

111

* if the clean-up fails for some reason

112

113

114

@Override

115

@After

116

public void tearDown() throws Exception {

117

fFacility.waitForJobs();

118

}

119

120

/**

121

* Run the TraceControlComponent.

122

123

public void testTraceSessionTree() throws Exception {

124

125

fProxy.setTestFile(fTestFile);

126

fProxy.setScenario(TraceControlTestFacility.SCEN_INIT_TEST);

127

128

ITraceControlComponent root = TraceControlTestFacility.getInstance().getControlView().getTraceControlRoot();

129

130

ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();

131

ISystemProfile profile = registry.createSystemProfile("myProfile", true);

132

IHost host = registry.createLocalHost(profile, "myProfile", "user");

133

134

TargetNodeComponent node = new TargetNodeComponent("myNode", root, host, fProxy);

135

136

root.addChild(node);

137

fFacility.waitForJobs();

138

139

fFacility.executeCommand(node, "connect");

140

int i = 0;

141

while ((i < 10) && (node.getTargetNodeState() != TargetNodeState.CONNECTED)) {

142

i++;

143

fFacility.delay(TraceControlTestFacility.GUI_REFESH_DELAY);

144

}

145

146

// Verify that node is connected

147

assertEquals(TargetNodeState.CONNECTED, node.getTargetNodeState());

148

149

// Get provider groups

150

ITraceControlComponent[] groups = node.getChildren();

151

assertNotNull(groups);

152

assertEquals(2, groups.length);

153

154

// Initialize dialog implementations for command execution

155

TraceControlDialogFactory.getInstance().setCreateSessionDialog(new CreateSessionDialogStub());

156

TraceControlDialogFactory.getInstance().setGetEventInfoDialog(new GetEventInfoDialogStub());

157

TraceControlDialogFactory.getInstance().setConfirmDialog(new DestroyConfirmDialogStub());

158

159

// Initialize session handling scenario

160

fProxy.setScenario(TraceControlTestFacility.SCEN_SCENARIO_SESSION_HANDLING);

161

162

// ------------------------------------------------------------------------

163

// Create session

164

// ------------------------------------------------------------------------

165

TraceSessionComponent session = fFacility.createSession(groups[1]);

166

167

// Verify that session was created

168

assertNotNull(session);

169

assertEquals("mysession", session.getName());

170

assertEquals("/home/user/lttng-traces/mysession-20120314-132824", session.getSessionPath());

171

assertEquals(TraceSessionState.INACTIVE, session.getSessionState());

172

173

// Initialize scenario

174

fProxy.setScenario(SCEN_SCENARIO3_TEST);

175

176

// ------------------------------------------------------------------------

177

// Enable channel on session

178

// ------------------------------------------------------------------------

179

EnableChannelDialogStub channelStub = new EnableChannelDialogStub();

180

channelStub.setIsKernel(true);

181

TraceControlDialogFactory.getInstance().setEnableChannelDialog(channelStub);

182

183

fFacility.executeCommand(session, "enableChannelOnSession");

184

185

// Verify that Kernel domain was created

186

ITraceControlComponent[] domains = session.getChildren();

187

assertNotNull(domains);

188

assertEquals(1, domains.length);

189

190

assertEquals("Kernel", domains[0].getName());

191

192

// Verify that channel was created with correct data

193

ITraceControlComponent[] channels = domains[0].getChildren();

194

assertNotNull(channels);

195

assertEquals(1, channels.length);

196

197

assertTrue(channels[0] instanceof TraceChannelComponent);

198

TraceChannelComponent channel = (TraceChannelComponent) channels[0];

199

assertEquals("mychannel", channel.getName());

200

assertEquals(4, channel.getNumberOfSubBuffers());

201

assertEquals("splice()", channel.getOutputType());

202

assertEquals(true, channel.isOverwriteMode());

203

assertEquals(200, channel.getReadTimer());

204

assertEquals(TraceEnablement.ENABLED, channel.getState());

205

assertEquals(16384, channel.getSubBufferSize());

206

assertEquals(100, channel.getSwitchTimer());

207

208

// ------------------------------------------------------------------------

209

// Create channel on domain

210

// ------------------------------------------------------------------------

211

ChannelInfo info = (ChannelInfo)channelStub.getChannelInfo();

212

info.setName("mychannel2");

213

info.setOverwriteMode(false);

214

info.setSubBufferSize(32768);

215

info.setNumberOfSubBuffers(2);

216

info.setSwitchTimer(100);

217

info.setReadTimer(200);

218

channelStub.setChannelInfo(info);

219

220

fFacility.executeCommand(domains[0], "enableChannelOnDomain");

221

222

// Get Kernel domain component instance

223

domains = session.getChildren();

224

assertNotNull(domains);

225

assertEquals(1, domains.length);

226

227

// Verify that channel was created with correct data

228

channels = domains[0].getChildren();

229

assertNotNull(channels);

230

assertEquals(2, channels.length);

231

232

assertTrue(channels[1] instanceof TraceChannelComponent);

233

channel = (TraceChannelComponent) channels[1];

234

assertEquals("mychannel2", channel.getName());

235

assertEquals(2, channel.getNumberOfSubBuffers());

236

assertEquals("splice()", channel.getOutputType());

237

assertEquals(false, channel.isOverwriteMode());

238

assertEquals(200, channel.getReadTimer());

239

assertEquals(TraceEnablement.ENABLED, channel.getState());

240

assertEquals(32768, channel.getSubBufferSize());

241

assertEquals(100, channel.getSwitchTimer());

242

243

EnableEventsDialogStub eventsDialogStub = new EnableEventsDialogStub();

244

eventsDialogStub.setIsTracePoints(true);

245

List<String> events = new ArrayList<String>();

246

events.add("sched_kthread_stop");

247

events.add("sched_kthread_stop_ret");

248

eventsDialogStub.setNames(events);

249

eventsDialogStub.setIsKernel(true);

250

TraceControlDialogFactory.getInstance().setEnableEventsDialog(eventsDialogStub);

251

252

// ------------------------------------------------------------------------

253

// disable channels

254

// ------------------------------------------------------------------------

255

// Get Kernel domain component instance

256

domains = session.getChildren();

257

assertNotNull(domains);

258

assertEquals(1, domains.length);

259

260

// Verify that channel was created with correct data

261

channels = domains[0].getChildren();

262

assertNotNull(channels);

263

assertEquals(2, channels.length);

264

265

fFacility.executeCommand(channels, "disableChannel");

266

267

assertEquals(TraceEnablement.DISABLED, ((TraceChannelComponent)channels[0]).getState());

268

assertEquals(TraceEnablement.DISABLED, ((TraceChannelComponent)channels[1]).getState());

269

270

// ------------------------------------------------------------------------

271

// enable channels

272

// ------------------------------------------------------------------------

273

// Get Kernel domain component instance

274

domains = session.getChildren();

275

assertNotNull(domains);

276

assertEquals(1, domains.length);

277

278

// Verify that channel was created with correct data

279

channels = domains[0].getChildren();

280

assertNotNull(channels);

281

assertEquals(2, channels.length);

282

283

fFacility.executeCommand(channels, "enableChannel");

284

285

assertEquals(TraceEnablement.ENABLED, ((TraceChannelComponent)channels[0]).getState());

286

assertEquals(TraceEnablement.ENABLED, ((TraceChannelComponent)channels[1]).getState());

287

288

// ------------------------------------------------------------------------

289

// enable event (tracepoints) on session

290

// ------------------------------------------------------------------------

291

fFacility.executeCommand(session, "enableEventOnSession");

292

293

// Get Kernel domain component instance

294

domains = session.getChildren();

295

assertNotNull(domains);

296

assertEquals(1, domains.length);

297

298

// Verify that channel was created with correct data

299

channels = domains[0].getChildren();

300

assertNotNull(channels);

301

assertEquals(3, channels.length);

302

303

assertTrue(channels[2] instanceof TraceChannelComponent);

304

channel = (TraceChannelComponent) channels[2];

305

assertEquals("channel0", channel.getName());

306

// No need to check parameters of default channel because that has been done in other tests

307

308

ITraceControlComponent[] channel0Events = channel.getChildren();

309

assertEquals(2, channel0Events.length);

310

311

assertTrue(channel0Events[0] instanceof TraceEventComponent);

312

assertTrue(channel0Events[1] instanceof TraceEventComponent);

313

314

TraceEventComponent event = (TraceEventComponent) channel0Events[0];

315

assertEquals("sched_kthread_stop_ret", event.getName());

316

assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

317

assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

318

assertEquals(TraceEnablement.ENABLED, event.getState());

319

320

event = (TraceEventComponent) channel0Events[1];

321

assertEquals("sched_kthread_stop", event.getName());

322

assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

323

assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

324

assertEquals(TraceEnablement.ENABLED, event.getState());

325

326

// ------------------------------------------------------------------------

327

// enable event (tracepoints) on domain

328

// ------------------------------------------------------------------------

329

events.clear();

330

events.add("sched_wakeup_new");

331

eventsDialogStub.setNames(events);

332

333

fFacility.executeCommand(domains[0], "enableEventOnDomain");

334

335

// Get Kernel domain component instance

336

domains = session.getChildren();

337

assertNotNull(domains);

338

assertEquals(1, domains.length);

339

340

// Verify that channel was created with correct data

341

channels = domains[0].getChildren();

342

channel = (TraceChannelComponent) channels[2];

343

// No need to check parameters of default channel because that has been done in other tests

344

345

channel = (TraceChannelComponent) channels[2];

346

347

channel0Events = channel.getChildren();

348

assertEquals(3, channel0Events.length);

349

350

assertTrue(channel0Events[2] instanceof TraceEventComponent);

351

352

event = (TraceEventComponent) channel0Events[2];

353

assertEquals("sched_wakeup_new", event.getName());

354

assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

355

assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

356

assertEquals(TraceEnablement.ENABLED, event.getState());

357

358

// ------------------------------------------------------------------------

359

// enable event (tracepoints) on channel

360

// ------------------------------------------------------------------------

361

events.clear();

362

eventsDialogStub.setNames(events);

363

eventsDialogStub.setIsAllTracePoints(true);

364

365

fFacility.executeCommand(channels[1], "enableEventOnChannel");

366

367

// Get Kernel domain component instance

368

domains = session.getChildren();

369

assertNotNull(domains);

370

assertEquals(1, domains.length);

371

372

// Verify that channel was created with correct data

373

channels = domains[0].getChildren();

374

// No need to check parameters of default channel because that has been done in other tests

375

channel = (TraceChannelComponent) channels[1];

376

377

channel0Events = channel.getChildren();

378

assertEquals(3, channel0Events.length);

379

380

assertTrue(channel0Events[0] instanceof TraceEventComponent);

381

assertTrue(channel0Events[1] instanceof TraceEventComponent);

382

assertTrue(channel0Events[2] instanceof TraceEventComponent);

383

384

event = (TraceEventComponent) channel0Events[0];

385

assertEquals("sched_kthread_stop_ret", event.getName());

386

assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

387

assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

388

assertEquals(TraceEnablement.ENABLED, event.getState());

389

390

event = (TraceEventComponent) channel0Events[1];

391

assertEquals("sched_kthread_stop", event.getName());

392

assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

393

assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

394

assertEquals(TraceEnablement.ENABLED, event.getState());

395

396

event = (TraceEventComponent) channel0Events[2];

397

assertEquals("sched_wakeup_new", event.getName());

398

assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

399

assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

400

assertEquals(TraceEnablement.ENABLED, event.getState());

401

402

// ------------------------------------------------------------------------

403

// enable event (syscall) on channel

404

// ------------------------------------------------------------------------

405

events.clear();

406

eventsDialogStub.setIsTracePoints(false);

407

eventsDialogStub.setIsAllTracePoints(false);

408

eventsDialogStub.setIsSysCalls(true);

409

410

fFacility.executeCommand(channels[0], "enableEventOnChannel");

411

412

// Get Kernel domain component instance

413

domains = session.getChildren();

414

assertNotNull(domains);

415

assertEquals(1, domains.length);

416

417

// Verify that channel was created with correct data

418

channels = domains[0].getChildren();

419

channel = (TraceChannelComponent) channels[0];

420

// No need to check parameters of default channel because that has been done in other tests

421

422

channel = (TraceChannelComponent) channels[0];

423

424

channel0Events = channel.getChildren();

425

assertEquals(1, channel0Events.length);

426

427

assertTrue(channel0Events[0] instanceof TraceEventComponent);

428

429

event = (TraceEventComponent) channel0Events[0];

430

assertEquals("syscalls", event.getName());

431

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());

432

assertEquals(TraceEventType.SYSCALL, event.getEventType());

433

assertEquals(TraceEnablement.ENABLED, event.getState());

434

435

// ------------------------------------------------------------------------

436

// enable event (syscall) on domain

437

// ------------------------------------------------------------------------

438

fFacility.executeCommand(domains[0], "enableEventOnDomain");

439

440

// Get Kernel domain component instance

441

domains = session.getChildren();

442

assertNotNull(domains);

443

assertEquals(1, domains.length);

444

445

// Verify that channel was created with correct data

446

channels = domains[0].getChildren();

447

channel = (TraceChannelComponent) channels[0];

448

// No need to check parameters of default channel because that has been done in other tests

449

450

channel = (TraceChannelComponent) channels[2];

451

452

channel0Events = channel.getChildren();

453

assertEquals(4, channel0Events.length);

454

455

assertTrue(channel0Events[0] instanceof TraceEventComponent);

456

457

event = (TraceEventComponent) channel0Events[0];

458

assertEquals("syscalls", event.getName());

459

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());

460

assertEquals(TraceEventType.SYSCALL, event.getEventType());

461

assertEquals(TraceEnablement.ENABLED, event.getState());

462

463

// ------------------------------------------------------------------------

464

// enable event (syscall) on session

465

// ------------------------------------------------------------------------

466

fFacility.executeCommand(session, "enableEventOnSession");

467

468

// Get Kernel domain component instance

469

domains = session.getChildren();

470

assertNotNull(domains);

471

assertEquals(1, domains.length);

472

473

// Verify that channel was created with correct data

474

channels = domains[0].getChildren();

475

channel = (TraceChannelComponent) channels[0];

476

// No need to check parameters of default channel because that has been done in other tests

477

478

channel = (TraceChannelComponent) channels[2];

479

480

channel0Events = channel.getChildren();

481

assertEquals(4, channel0Events.length);

482

483

assertTrue(channel0Events[0] instanceof TraceEventComponent);

484

485

event = (TraceEventComponent) channel0Events[0];

486

assertEquals("syscalls", event.getName());

487

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());

488

assertEquals(TraceEventType.SYSCALL, event.getEventType());

489

assertEquals(TraceEnablement.ENABLED, event.getState());

490

491

492

// ------------------------------------------------------------------------

493

// enable event (dynamic probe) on domain

494

// ------------------------------------------------------------------------

495

events.clear();

496

eventsDialogStub.setIsSysCalls(false);

497

eventsDialogStub.setIsDynamicProbe(true);

498

eventsDialogStub.setDynamicProbe("0xc0101280");

499

eventsDialogStub.setProbeEventName("myevent1");

500

501

fFacility.executeCommand(domains[0], "enableEventOnDomain");

502

503

// Get Kernel domain component instance

504

domains = session.getChildren();

505

assertNotNull(domains);

506

assertEquals(1, domains.length);

507

508

// Verify that channel was created with correct data

509

channels = domains[0].getChildren();

510

channel = (TraceChannelComponent) channels[2];

511

// No need to check parameters of default channel because that has been done in other tests

512

513

channel0Events = channel.getChildren();

514

assertEquals(5, channel0Events.length);

515

516

assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);

517

518

TraceProbeEventComponent probeEvent = (TraceProbeEventComponent) channel0Events[0];

519

assertEquals("myevent1", probeEvent.getName());

520

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());

521

assertEquals(TraceEventType.PROBE, probeEvent.getEventType());

522

assertEquals(TraceEnablement.ENABLED, probeEvent.getState());

523

assertNull(probeEvent.getOffset());

524

assertEquals("0xc0101280", probeEvent.getAddress());

525

assertNull(probeEvent.getSymbol());

526

527

// ------------------------------------------------------------------------

528

// enable event (dynamic probe) on channel

529

// ------------------------------------------------------------------------

530

eventsDialogStub.setIsDynamicProbe(true);

531

eventsDialogStub.setDynamicProbe("init_post");

532

eventsDialogStub.setProbeEventName("myevent2");

533

534

fFacility.executeCommand(channels[2], "enableEventOnChannel");

535

536

// Get Kernel domain component instance

537

domains = session.getChildren();

538

assertNotNull(domains);

539

assertEquals(1, domains.length);

540

541

// Verify that channel was created with correct data

542

channels = domains[0].getChildren();

543

channel = (TraceChannelComponent) channels[2];

544

// No need to check parameters of default channel because that has been done in other tests

545

546

channel0Events = channel.getChildren();

547

assertEquals(6, channel0Events.length);

548

549

assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);

550

551

probeEvent = (TraceProbeEventComponent) channel0Events[0];

552

assertEquals("myevent2", probeEvent.getName());

553

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());

554

assertEquals(TraceEventType.PROBE, probeEvent.getEventType());

555

assertEquals(TraceEnablement.ENABLED, probeEvent.getState());

556

assertEquals("0x0", probeEvent.getOffset());

557

assertNull(null, probeEvent.getAddress());

558

assertEquals("init_post", probeEvent.getSymbol());

559

560

// ------------------------------------------------------------------------

561

// enable event (dynamic probe) on session

562

// ------------------------------------------------------------------------

563

eventsDialogStub.setIsDynamicProbe(true);

564

eventsDialogStub.setDynamicProbe("init_post:0x1000");

565

eventsDialogStub.setProbeEventName("myevent3");

566

567

fFacility.executeCommand(session, "enableEventOnSession");

568

569

// Get Kernel domain component instance

570

domains = session.getChildren();

571

assertNotNull(domains);

572

assertEquals(1, domains.length);

573

574

// Verify that channel was created with correct data

575

channels = domains[0].getChildren();

576

channel = (TraceChannelComponent) channels[2];

577

// No need to check parameters of default channel because that has been done in other tests

578

579

channel0Events = channel.getChildren();

580

assertEquals(7, channel0Events.length);

581

582

assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);

583

584

probeEvent = (TraceProbeEventComponent) channel0Events[0];

585

assertEquals("myevent3", probeEvent.getName());

586

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());

587

assertEquals(TraceEventType.PROBE, probeEvent.getEventType());

588

assertEquals(TraceEnablement.ENABLED, probeEvent.getState());

589

assertEquals("0x1000", probeEvent.getOffset());

590

assertNull(null, probeEvent.getAddress());

591

assertEquals("init_post", probeEvent.getSymbol());

592

593

// ------------------------------------------------------------------------

594

// enable event (dynamic function probe) on session

595

// ------------------------------------------------------------------------

596

eventsDialogStub.setIsDynamicProbe(false);

597

eventsDialogStub.setDynamicProbe(null);

598

eventsDialogStub.setProbeEventName(null);

599

eventsDialogStub.setIsFunctionProbe(true);

600

eventsDialogStub.setFunctionEventName("myevent4");

601

eventsDialogStub.setFunctionProbe("create_dev");

602

603

fFacility.executeCommand(session, "enableEventOnSession");

604

605

// Get Kernel domain component instance

606

domains = session.getChildren();

607

assertNotNull(domains);

608

assertEquals(1, domains.length);

609

610

// Verify that channel was created with correct data

611

channels = domains[0].getChildren();

612

channel = (TraceChannelComponent) channels[2];

613

// No need to check parameters of default channel because that has been done in other tests

614

615

channel0Events = channel.getChildren();

616

assertEquals(8, channel0Events.length);

617

618

assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);

619

620

probeEvent = (TraceProbeEventComponent) channel0Events[0];

621

assertEquals("myevent4", probeEvent.getName());

622

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());

623

assertEquals(TraceEventType.PROBE, probeEvent.getEventType());

624

assertEquals(TraceEnablement.ENABLED, probeEvent.getState());

625

assertEquals("0x0", probeEvent.getOffset());

626

assertNull(null, probeEvent.getAddress());

627

assertEquals("create_dev", probeEvent.getSymbol());

628

629

// ------------------------------------------------------------------------

630

// enable event (dynamic function probe) on domain

631

// ------------------------------------------------------------------------

632

eventsDialogStub.setIsFunctionProbe(true);

633

eventsDialogStub.setFunctionEventName("myevent5");

634

eventsDialogStub.setFunctionProbe("create_dev:0x2000");

635

636

fFacility.executeCommand(domains[0], "enableEventOnDomain");

637

638

// Get Kernel domain component instance

639

domains = session.getChildren();

640

assertNotNull(domains);

641

assertEquals(1, domains.length);

642

643

// Verify that channel was created with correct data

644

channels = domains[0].getChildren();

645

channel = (TraceChannelComponent) channels[2];

646

// No need to check parameters of default channel because that has been done in other tests

647

648

channel0Events = channel.getChildren();

649

assertEquals(9, channel0Events.length);

650

651

assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);

652

653

probeEvent = (TraceProbeEventComponent) channel0Events[0];

654

assertEquals("myevent5", probeEvent.getName());

655

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());

656

assertEquals(TraceEventType.PROBE, probeEvent.getEventType());

657

assertEquals(TraceEnablement.ENABLED, probeEvent.getState());

658

assertEquals("0x2000", probeEvent.getOffset());

659

assertNull(null, probeEvent.getAddress());

660

assertEquals("create_dev", probeEvent.getSymbol());

661

662

// ------------------------------------------------------------------------

663

// enable event (dynamic function probe) on channel

664

// ------------------------------------------------------------------------

665

eventsDialogStub.setIsFunctionProbe(true);

666

eventsDialogStub.setFunctionEventName("myevent");

667

eventsDialogStub.setFunctionProbe("create_dev:0x2000");

668

669

fFacility.executeCommand(channels[0], "enableEventOnChannel");

670

671

// Get Kernel domain component instance

672

domains = session.getChildren();

673

assertNotNull(domains);

674

assertEquals(1, domains.length);

675

676

// Verify that channel was created with correct data

677

channels = domains[0].getChildren();

678

channel = (TraceChannelComponent) channels[0];

679

// No need to check parameters of default channel because that has been done in other tests

680

681

channel0Events = channel.getChildren();

682

assertEquals(2, channel0Events.length);

683

684

assertTrue(channel0Events[0] instanceof TraceProbeEventComponent);

685

686

probeEvent = (TraceProbeEventComponent) channel0Events[0];

687

assertEquals("myevent", probeEvent.getName());

688

assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());

689

assertEquals(TraceEventType.PROBE, probeEvent.getEventType());

690

assertEquals(TraceEnablement.ENABLED, probeEvent.getState());

691

assertEquals("0x2000", probeEvent.getOffset());

692

assertNull(null, probeEvent.getAddress());

693

assertEquals("create_dev", probeEvent.getSymbol());

694

695

// ------------------------------------------------------------------------

696

// Add Context on domain

697

// ------------------------------------------------------------------------

698

// Get Kernel domain component instance

699

domains = session.getChildren();

700

assertNotNull(domains);

701

assertEquals(1, domains.length);

702

703

AddContextDialogStub addContextStub = new AddContextDialogStub();

704

List<String> contexts = new ArrayList<String>();

705

contexts.add("prio");

706

contexts.add("perf:branch-misses");

707

contexts.add("perf:cache-misses");

708

addContextStub.setContexts(contexts);

709

TraceControlDialogFactory.getInstance().setAddContextDialog(addContextStub);

710

711

fFacility.executeCommand(domains[0], "addContextOnDomain");

712

// Currently there is nothing to verify because the list commands don't show any context information

713

// However, the execution of the command make sure that the correct service command line is build and executed.

714

715

// ------------------------------------------------------------------------

716

// Add Context on channel

717

// ------------------------------------------------------------------------

718

719

// Get Kernel domain component instance

720

domains = session.getChildren();

721

assertNotNull(domains);

722

assertEquals(1, domains.length);

723

724

//Verify that channel was created with correct data

725

channels = domains[0].getChildren();

726

channel = (TraceChannelComponent) channels[0];

727

728

try {

729

// The setContext() verifies that the contexts set are part of the available contexts

730

// The available contexts are set by the command handler addContextOnDomain above.

731

// So we indirectly test here that the parsing and setting of available contexts were

732

// done correctly above.

733

addContextStub.setContexts(contexts);

734

} catch (IllegalArgumentException e) {

735

fail("Exception caught - unknown context");

736

}

737

738

fFacility.executeCommand(channel, "addContextOnChannel");

739

// Currently there is nothing to verify because the list commands don't show any context information

740

// However, the execution of the command make sure that the correct service command line is build and executed.

741

742

// ------------------------------------------------------------------------

743

// Add Context on event

744

// ------------------------------------------------------------------------

745

// Get Kernel domain component instance

746

domains = session.getChildren();

747

assertNotNull(domains);

748

assertEquals(1, domains.length);

749

750

//Verify that channel was created with correct data

751

channels = domains[0].getChildren();

752

channel = (TraceChannelComponent) channels[2];

753

754

channel0Events = channel.getChildren();

755

756

event = (TraceEventComponent) channel0Events[6];

757

758

fFacility.executeCommand(event, "addContextOnEvent");

759

// Currently there is nothing to verify because the list commands don't show any context information

760

// However, the execution of the command make sure that the correct service command line is build and executed.

761

762

// ------------------------------------------------------------------------

763

// Calibrate

764

// ------------------------------------------------------------------------

765

// Get Kernel domain component instance

766

domains = session.getChildren();

767

assertNotNull(domains);

768

assertEquals(1, domains.length);

769

770

fFacility.executeCommand(domains[0], "calibrate");

771

// There is nothing to verify here.

772

// However, the execution of the command make sure that the correct service command line is build and executed.

773

774

// ------------------------------------------------------------------------

775

// refresh

776

// ------------------------------------------------------------------------

777

fFacility.executeCommand(node, "refresh");

778

groups = node.getChildren();

779

assertNotNull(groups);

780

assertEquals(2, groups.length);

781

assertEquals(3, groups[0].getChildren().length); // provider

782

assertEquals(1, groups[1].getChildren().length); // sessions

783

assertEquals(1, groups[1].getChildren()[0].getChildren().length); // domains

784

assertEquals(3, groups[1].getChildren()[0].getChildren()[0].getChildren().length); // channels

785

assertEquals(2, groups[1].getChildren()[0].getChildren()[0].getChildren()[0].getChildren().length); // events (of channel[0])

786

787

// Initialize session handling scenario

788

fProxy.setScenario(TraceControlTestFacility.SCEN_SCENARIO_SESSION_HANDLING);

789

790

session = (TraceSessionComponent)groups[1].getChildren()[0];

791

792

// ------------------------------------------------------------------------

793

// start session

794

// ------------------------------------------------------------------------

795

fFacility.startSession(session);

796

assertEquals(TraceSessionState.ACTIVE, session.getSessionState());

797

798

// ------------------------------------------------------------------------

799

// stop session

800

// ------------------------------------------------------------------------

801

fFacility.stopSession(session);

802

assertEquals(TraceSessionState.INACTIVE, session.getSessionState());

803

804

// ------------------------------------------------------------------------

805

// Destroy session

806

// ------------------------------------------------------------------------

807

808

fFacility.destroySession(session);

809

810

// Verify that no more session components exist

811

assertEquals(0, groups[1].getChildren().length);

812

813

//-------------------------------------------------------------------------

814

// Disconnect node

815

//-------------------------------------------------------------------------

816

fFacility.executeCommand(node, "disconnect");

817

assertEquals(TargetNodeState.DISCONNECTED, node.getTargetNodeState());

818

819

//-------------------------------------------------------------------------

820

// Delete node

821

//-------------------------------------------------------------------------

822

823

fFacility.executeCommand(node, "delete");

824

assertEquals(0,fFacility.getControlView().getTraceControlRoot().getChildren().length);

825

}

826

827

}

b'\\ No newline at end of file'

Older »