Print this page
4719 Common patchset for jdk1.7 support preparation
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/dtrace/test/tst/common/java_api/src/TestStateMachine.java
+++ new/usr/src/cmd/dtrace/test/tst/common/java_api/src/TestStateMachine.java
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 *
26 26 * ident "%Z%%M% %I% %E% SMI"
27 27 */
28 28
29 29 import org.opensolaris.os.dtrace.*;
30 30
31 31 /**
32 32 * Regression test for the LocalConsumer state machine. Calls Consumer
33 33 * methods before and after open(), compile(), enable(), go(), stop(),
34 34 * and close() to verify that the calls succeed as expected or fail with
35 35 * the expected Java exception.
36 36 */
37 37 public class TestStateMachine {
38 38 static Program program;
39 39
40 40 static void
41 41 exit(int status)
42 42 {
43 43 exit(status, null);
44 44 }
45 45
46 46 static void
47 47 exit(int status, String msg)
48 48 {
49 49 if (msg != null) {
50 50 System.out.println(msg);
51 51 }
52 52 System.out.flush();
53 53 System.err.flush();
54 54 System.exit(status);
55 55 }
56 56
57 57 static void
58 58 printState(Consumer consumer)
59 59 {
60 60 System.out.println("open: " + consumer.isOpen());
61 61 System.out.println("enabled: " + consumer.isEnabled());
62 62 System.out.println("closed: " + consumer.isClosed());
63 63 }
64 64
65 65 static void
66 66 beforeOpen(Consumer consumer)
67 67 {
68 68 System.out.println("before open");
69 69 printState(consumer);
70 70
71 71 // compile
72 72 try {
73 73 consumer.compile("syscall:::entry");
74 74 exit(1, "compile before open");
75 75 } catch (IllegalStateException e) {
76 76 System.out.println(e);
77 77 } catch (Exception e) {
78 78 e.printStackTrace();
79 79 exit(1, "compile before open");
80 80 }
81 81
82 82 // enable
83 83 try {
84 84 consumer.enable();
85 85 exit(1, "enable before open");
86 86 } catch (IllegalStateException e) {
87 87 System.out.println(e);
88 88 } catch (Exception e) {
89 89 e.printStackTrace();
90 90 exit(1, "enable before open");
91 91 }
92 92
93 93 // getOption, setOption, unsetOption
94 94 try {
95 95 consumer.getOption(Option.bufsize);
96 96 exit(1, "getOption before open");
97 97 } catch (IllegalStateException e) {
98 98 System.out.println(e);
99 99 } catch (Exception e) {
100 100 e.printStackTrace();
101 101 exit(1, "getOption before open");
102 102 }
103 103 try {
104 104 consumer.setOption(Option.bufsize, Option.mb(1));
105 105 exit(1, "setOption before open");
106 106 } catch (IllegalStateException e) {
107 107 System.out.println(e);
108 108 } catch (Exception e) {
109 109 e.printStackTrace();
110 110 exit(1, "setOption before open");
111 111 }
112 112 try {
113 113 consumer.unsetOption(Option.quiet);
114 114 exit(1, "unsetOption before open");
115 115 } catch (IllegalStateException e) {
116 116 System.out.println(e);
117 117 } catch (Exception e) {
118 118 e.printStackTrace();
119 119 exit(1, "unsetOption before open");
120 120 }
121 121
122 122 // createProcess, grabProcess
123 123 try {
124 124 consumer.createProcess("date");
125 125 exit(1, "createProcess before open");
126 126 } catch (IllegalStateException e) {
127 127 System.out.println(e);
128 128 } catch (Exception e) {
129 129 e.printStackTrace();
130 130 exit(1, "createProcess before open");
131 131 }
132 132 try {
133 133 consumer.grabProcess(1);
134 134 exit(1, "grabProcess before open");
135 135 } catch (IllegalStateException e) {
136 136 System.out.println(e);
137 137 } catch (Exception e) {
138 138 e.printStackTrace();
139 139 exit(1, "grabProcess before open");
140 140 }
141 141
142 142 // listProbes
143 143 try {
144 144 consumer.listProbes(ProbeDescription.EMPTY);
145 145 exit(1, "listProbes before open");
146 146 } catch (IllegalStateException e) {
147 147 System.out.println(e);
148 148 } catch (Exception e) {
149 149 e.printStackTrace();
150 150 exit(1, "listProbes before open");
151 151 }
152 152
153 153 // getAggregate
154 154 try {
155 155 consumer.getAggregate();
156 156 exit(1, "getAggregate before open");
157 157 } catch (IllegalStateException e) {
158 158 System.out.println(e);
159 159 } catch (Exception e) {
160 160 e.printStackTrace();
161 161 exit(1, "getAggregate before open");
162 162 }
163 163
164 164 // getVersion
165 165 try {
166 166 consumer.getVersion(); // allowed
167 167 } catch (Exception e) {
168 168 e.printStackTrace();
169 169 exit(1, "getVersion before open");
170 170 }
171 171 }
172 172
173 173 static void
174 174 beforeCompile(Consumer consumer)
175 175 {
176 176 System.out.println("before compile");
177 177 printState(consumer);
178 178
179 179 // open
180 180 try {
181 181 consumer.open();
182 182 exit(1, "open after open");
183 183 } catch (IllegalStateException e) {
184 184 System.out.println(e);
185 185 } catch (Exception e) {
186 186 e.printStackTrace();
187 187 exit(1, "open after open");
188 188 }
189 189
190 190 // enable
191 191 try {
192 192 consumer.enable();
193 193 exit(1, "enable before compile");
194 194 } catch (IllegalStateException e) {
195 195 System.out.println(e);
196 196 } catch (Exception e) {
197 197 e.printStackTrace();
198 198 exit(1, "enable before compile");
199 199 }
200 200 }
201 201
202 202 static void
203 203 beforeEnable(Consumer consumer)
204 204 {
205 205 System.out.println("before enable");
206 206 printState(consumer);
207 207
208 208 // go
209 209 try {
210 210 consumer.go();
211 211 exit(1, "go before enable");
212 212 } catch (IllegalStateException e) {
213 213 System.out.println(e);
214 214 } catch (Exception e) {
215 215 e.printStackTrace();
216 216 exit(1, "go before enable");
217 217 }
218 218 }
219 219
220 220 static void
221 221 beforeGo(Consumer consumer)
222 222 {
223 223 System.out.println("before go");
224 224 printState(consumer);
225 225
226 226 // getAggregate
227 227 try {
228 228 consumer.getAggregate();
229 229 exit(1, "getAggregate before go");
230 230 } catch (IllegalStateException e) {
231 231 System.out.println(e);
232 232 } catch (Exception e) {
233 233 e.printStackTrace();
234 234 exit(1, "getAggregate before go");
235 235 }
236 236
237 237 // lookupKernelFunction, lookupUserFunction
238 238 try {
239 239 consumer.lookupKernelFunction(1);
240 240 exit(1, "lookupKernelFunction before go");
241 241 } catch (IllegalStateException e) {
242 242 System.out.println(e);
243 243 } catch (Exception e) {
244 244 e.printStackTrace();
245 245 exit(1, "lookupKernelFunction before go");
246 246 }
247 247 try {
248 248 consumer.lookupUserFunction(1, 1);
249 249 exit(1, "lookupUserFunction before go");
250 250 } catch (IllegalStateException e) {
251 251 System.out.println(e);
252 252 } catch (Exception e) {
253 253 e.printStackTrace();
254 254 exit(1, "lookupUserFunction before go");
255 255 }
256 256
257 257 // stop
258 258 try {
259 259 consumer.stop();
260 260 exit(1, "stop before go");
261 261 } catch (IllegalStateException e) {
262 262 System.out.println(e);
263 263 } catch (Exception e) {
264 264 e.printStackTrace();
265 265 exit(1, "stop before go");
266 266 }
267 267 }
268 268
269 269 static void
270 270 afterGo(Consumer consumer, Program program)
271 271 {
272 272 System.out.println("after go");
273 273 printState(consumer);
274 274
275 275 // go
276 276 try {
277 277 consumer.go();
278 278 exit(1, "go after go");
279 279 } catch (IllegalStateException e) {
280 280 System.out.println(e);
281 281 } catch (Exception e) {
282 282 e.printStackTrace();
283 283 exit(1, "go after go");
284 284 }
285 285
286 286 // createProcess, grabProcess
287 287 try {
288 288 consumer.createProcess("date");
289 289 exit(1, "createProcess after go");
290 290 } catch (IllegalStateException e) {
291 291 System.out.println(e);
292 292 } catch (Exception e) {
293 293 e.printStackTrace();
294 294 exit(1, "createProcess after go");
295 295 }
296 296 try {
297 297 consumer.grabProcess(1);
298 298 exit(1, "grabProcess after go");
299 299 } catch (IllegalStateException e) {
300 300 System.out.println(e);
301 301 } catch (Exception e) {
302 302 e.printStackTrace();
303 303 exit(1, "grabProcess after go");
304 304 }
305 305
306 306 // listProbes
307 307 try {
308 308 consumer.listProbes(ProbeDescription.EMPTY);
309 309 exit(1, "listProbes after go");
310 310 } catch (IllegalStateException e) {
311 311 System.out.println(e);
312 312 } catch (Exception e) {
313 313 e.printStackTrace();
314 314 exit(1, "listProbes after go");
315 315 }
316 316
317 317 // compile
318 318 try {
319 319 consumer.compile("syscall:::entry");
320 320 exit(1, "compile after go");
321 321 } catch (IllegalStateException e) {
322 322 System.out.println(e);
323 323 } catch (Exception e) {
324 324 e.printStackTrace();
325 325 exit(1, "compile after go");
326 326 }
327 327
328 328 // enable
329 329 try {
330 330 consumer.enable();
331 331 exit(1, "enable after go");
332 332 } catch (IllegalStateException e) {
333 333 System.out.println(e);
334 334 } catch (Exception e) {
335 335 e.printStackTrace();
336 336 exit(1, "enable after go");
337 337 }
338 338
339 339 // getAggregate
340 340 try {
341 341 consumer.getAggregate();
342 342 } catch (Exception e) {
343 343 e.printStackTrace();
344 344 exit(1, "getAggregate after go");
345 345 }
346 346
347 347 // getProgramInfo
348 348 try {
349 349 consumer.getProgramInfo(program);
350 350 } catch (Exception e) {
351 351 e.printStackTrace();
352 352 exit(1, "getProgramInfo after go");
353 353 }
354 354
355 355 // getOption, setOption, unsetOption
356 356 try {
357 357 consumer.getOption(Option.quiet);
358 358 consumer.setOption(Option.quiet);
359 359 consumer.unsetOption(Option.quiet);
360 360 } catch (Exception e) {
361 361 e.printStackTrace();
362 362 exit(1, "get, set, unset option after go");
363 363 }
364 364 }
365 365
366 366 static void
367 367 afterStop(Consumer consumer, Program program)
368 368 {
369 369 System.out.println("after stop");
370 370 printState(consumer);
371 371
372 372 // stop
373 373 try {
374 374 consumer.stop();
375 375 exit(1, "stop after stop");
376 376 } catch (IllegalStateException e) {
377 377 System.out.println(e);
378 378 } catch (Exception e) {
379 379 e.printStackTrace();
380 380 exit(1, "stop after stop");
381 381 }
382 382
383 383 // getAggregate
384 384 try {
385 385 consumer.getAggregate();
386 386 } catch (Exception e) {
387 387 e.printStackTrace();
388 388 exit(1, "getAggregate after stop");
389 389 }
390 390
391 391 // getProgramInfo
392 392 try {
393 393 consumer.getProgramInfo(program);
394 394 } catch (Exception e) {
395 395 e.printStackTrace();
396 396 exit(1, "getProgramInfo after stop");
397 397 }
398 398
399 399 // getOption, setOption, unsetOption
400 400 try {
401 401 consumer.getOption(Option.quiet);
402 402 consumer.setOption(Option.quiet);
403 403 consumer.unsetOption(Option.quiet);
404 404 } catch (Exception e) {
405 405 e.printStackTrace();
406 406 exit(1, "get, set, unset option after stop");
407 407 }
408 408 }
409 409
410 410 static void
411 411 afterClose(Consumer consumer, Program program)
412 412 {
413 413 System.out.println("after close");
414 414 printState(consumer);
415 415
416 416 // open
417 417 try {
418 418 consumer.open();
419 419 exit(1, "open after close");
420 420 } catch (IllegalStateException e) {
421 421 System.out.println(e);
422 422 } catch (Exception e) {
423 423 e.printStackTrace();
424 424 exit(1, "open after close");
425 425 }
426 426
427 427 // compile
428 428 try {
429 429 consumer.compile("syscall:::entry");
430 430 exit(1, "compile after close");
431 431 } catch (IllegalStateException e) {
432 432 System.out.println(e);
433 433 } catch (Exception e) {
434 434 e.printStackTrace();
435 435 exit(1, "compile after close");
436 436 }
437 437
438 438 // enable
439 439 try {
440 440 consumer.enable();
441 441 exit(1, "enable after close");
442 442 } catch (IllegalStateException e) {
443 443 System.out.println(e);
444 444 } catch (Exception e) {
445 445 e.printStackTrace();
446 446 exit(1, "enable after close");
447 447 }
448 448
449 449 // getOption, setOption, unsetOption
450 450 try {
451 451 consumer.getOption(Option.bufsize);
452 452 exit(1, "getOption after close");
453 453 } catch (IllegalStateException e) {
454 454 System.out.println(e);
455 455 } catch (Exception e) {
456 456 e.printStackTrace();
457 457 exit(1, "getOption after close");
458 458 }
459 459 try {
460 460 consumer.setOption(Option.bufsize, Option.mb(1));
461 461 exit(1, "setOption after close");
462 462 } catch (IllegalStateException e) {
463 463 System.out.println(e);
464 464 } catch (Exception e) {
465 465 e.printStackTrace();
466 466 exit(1, "setOption after close");
467 467 }
468 468 try {
469 469 consumer.unsetOption(Option.quiet);
470 470 exit(1, "unsetOption after close");
471 471 } catch (IllegalStateException e) {
472 472 System.out.println(e);
473 473 } catch (Exception e) {
474 474 e.printStackTrace();
475 475 exit(1, "unsetOption after close");
476 476 }
477 477
478 478 // createProcess, grabProcess
479 479 try {
480 480 consumer.createProcess("date");
481 481 exit(1, "createProcess after close");
482 482 } catch (IllegalStateException e) {
483 483 System.out.println(e);
484 484 } catch (Exception e) {
485 485 e.printStackTrace();
486 486 exit(1, "createProcess after close");
487 487 }
488 488 try {
489 489 consumer.grabProcess(1);
490 490 exit(1, "grabProcess after close");
491 491 } catch (IllegalStateException e) {
492 492 System.out.println(e);
493 493 } catch (Exception e) {
494 494 e.printStackTrace();
495 495 exit(1, "grabProcess after close");
496 496 }
497 497
498 498 // listProbes
499 499 try {
500 500 consumer.listProbes(ProbeDescription.EMPTY);
501 501 exit(1, "listProbes after close");
502 502 } catch (IllegalStateException e) {
503 503 System.out.println(e);
504 504 } catch (Exception e) {
505 505 e.printStackTrace();
506 506 exit(1, "listProbes after close");
507 507 }
508 508
509 509 // getAggregate
510 510 try {
511 511 consumer.getAggregate();
512 512 exit(1, "getAggregate after close");
513 513 } catch (IllegalStateException e) {
514 514 System.out.println(e);
515 515 } catch (Exception e) {
516 516 e.printStackTrace();
517 517 exit(1, "getAggregate after close");
518 518 }
519 519
520 520 // getVersion
521 521 try {
522 522 consumer.getVersion(); // allowed
523 523 } catch (Exception e) {
524 524 e.printStackTrace();
525 525 exit(1, "getVersion after close");
526 526 }
527 527
528 528 // go
529 529 try {
530 530 consumer.go();
531 531 exit(1, "go after close");
532 532 } catch (IllegalStateException e) {
533 533 System.out.println(e);
534 534 } catch (Exception e) {
535 535 e.printStackTrace();
536 536 exit(1, "go after close");
537 537 }
538 538
539 539 // lookupKernelFunction, lookupUserFunction
540 540 try {
541 541 consumer.lookupKernelFunction(1);
542 542 exit(1, "lookupKernelFunction after close");
543 543 } catch (IllegalStateException e) {
544 544 System.out.println(e);
545 545 } catch (Exception e) {
546 546 e.printStackTrace();
547 547 exit(1, "lookupKernelFunction after close");
548 548 }
549 549 try {
550 550 consumer.lookupUserFunction(1, 1);
551 551 exit(1, "lookupUserFunction after close");
552 552 } catch (IllegalStateException e) {
553 553 System.out.println(e);
554 554 } catch (Exception e) {
555 555 e.printStackTrace();
556 556 exit(1, "lookupUserFunction after close");
557 557 }
558 558
559 559 // stop
560 560 try {
561 561 consumer.stop();
562 562 exit(1, "stop after close");
563 563 } catch (IllegalStateException e) {
564 564 System.out.println(e);
565 565 } catch (Exception e) {
566 566 e.printStackTrace();
567 567 exit(1, "stop after close");
568 568 }
569 569
570 570 // getProgramInfo
571 571 try {
572 572 consumer.getProgramInfo(program);
573 573 exit(1, "getProgramInfo after close");
574 574 } catch (IllegalStateException e) {
575 575 System.out.println(e);
576 576 } catch (Exception e) {
577 577 e.printStackTrace();
578 578 exit(1, "getProgramInfo after close");
579 579 }
580 580 }
581 581
582 582 public static void
583 583 main(String[] args)
584 584 {
585 585 final Consumer consumer = new LocalConsumer();
586 586 consumer.addConsumerListener(new ConsumerAdapter() {
587 587 public void consumerStarted(ConsumerEvent e) {
588 588 System.out.println("consumerStarted, running: " +
589 589 consumer.isRunning());
590 590 afterGo(consumer, program);
591 591 }
592 592 public void consumerStopped(ConsumerEvent e) {
593 593 System.out.println("consumerStopped, running: " +
594 594 consumer.isRunning());
595 595 }
596 596 });
597 597
598 598 try {
599 599 beforeOpen(consumer);
600 600 consumer.open();
601 601 beforeCompile(consumer);
|
↓ open down ↓ |
601 lines elided |
↑ open up ↑ |
602 602 program = consumer.compile(
603 603 "syscall:::entry { @[execname] = count(); } " +
604 604 "tick-101ms { printa(@); }");
605 605 beforeEnable(consumer);
606 606 consumer.enable();
607 607 beforeGo(consumer);
608 608 System.out.println("before go, running: " + consumer.isRunning());
609 609 consumer.go();
610 610 // Avoid race, call afterGo() in ConsumerListener
611 611 try {
612 - Thread.currentThread().sleep(300);
612 + Thread.sleep(300);
613 613 } catch (InterruptedException e) {
614 614 e.printStackTrace();
615 615 exit(1);
616 616 }
617 617 consumer.stop();
618 618 System.out.println("after stop, running: " + consumer.isRunning());
619 619 afterStop(consumer, program);
620 620 consumer.close();
621 621 afterClose(consumer, program);
622 622 } catch (DTraceException e) {
623 623 e.printStackTrace();
624 624 exit(1);
625 625 }
626 626 }
627 627 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX