cddl/contrib/opensolaris/cmd/dtrace/test/tst/common/java_api/src/TestStateMachine.java

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