test/jdk/jdk/jfr/api/consumer/recordingstream/TestSetEndTime.java
branchJEP-349-branch
changeset 57848 bd961c64ecce
parent 57690 9316d02dd4a5
child 57949 74a38c0b5054
equal deleted inserted replaced
57784:88316b070ab9 57848:bd961c64ecce
    22  * or visit www.oracle.com if you need additional information or have any
    22  * or visit www.oracle.com if you need additional information or have any
    23  * questions.
    23  * questions.
    24  */
    24  */
    25 package jdk.jfr.api.consumer.recordingstream;
    25 package jdk.jfr.api.consumer.recordingstream;
    26 
    26 
       
    27 import java.nio.file.Path;
       
    28 import java.nio.file.Paths;
    27 import java.time.Duration;
    29 import java.time.Duration;
    28 import java.time.Instant;
    30 import java.time.Instant;
    29 import java.util.concurrent.atomic.AtomicBoolean;
    31 import java.util.concurrent.atomic.AtomicBoolean;
    30 
    32 
    31 import jdk.jfr.Event;
    33 import jdk.jfr.Event;
    32 import jdk.jfr.Name;
    34 import jdk.jfr.Name;
    33 import jdk.jfr.Recording;
    35 import jdk.jfr.Recording;
    34 import jdk.jfr.StackTrace;
    36 import jdk.jfr.StackTrace;
    35 import jdk.jfr.consumer.EventStream;
    37 import jdk.jfr.consumer.EventStream;
       
    38 import jdk.jfr.consumer.RecordedEvent;
       
    39 import jdk.jfr.consumer.RecordingFile;
    36 
    40 
    37 /**
    41 /**
    38  * @test
    42  * @test
    39  * @summary Tests EventStream::setEndTime
    43  * @summary Tests EventStream::setEndTime
    40  * @key jfr
    44  * @key jfr
    52 
    56 
    53     public static void main(String... args) throws Exception {
    57     public static void main(String... args) throws Exception {
    54         try (Recording r = new Recording()) {
    58         try (Recording r = new Recording()) {
    55             r.setFlushInterval(Duration.ofSeconds(1));
    59             r.setFlushInterval(Duration.ofSeconds(1));
    56             r.start();
    60             r.start();
    57             Instant start = Instant.now();
       
    58             System.out.println("Instant.start() = " + start);
       
    59             Thread.sleep(2000);
       
    60             Mark event1 = new Mark();
    61             Mark event1 = new Mark();
    61             event1.before = true;
    62             event1.before = true;
    62             event1.commit();
    63             advanceClock();
    63             Thread.sleep(2000);
    64             event1.commit(); // start time
    64             Instant end = Instant.now();
    65 
    65             System.out.println("Instant.end() = " + end);
       
    66             Thread.sleep(2000);
       
    67             Mark event2 = new Mark();
    66             Mark event2 = new Mark();
       
    67             event2.begin();  // end time
       
    68             advanceClock();
       
    69           //  event2.end();
       
    70             Thread.sleep(100);
    68             event2.before = false;
    71             event2.before = false;
    69             event2.commit();
    72             event2.commit();
       
    73 
       
    74             Path p = Paths.get("recording.jfr");
       
    75             r.dump(p);
       
    76             Instant start = null;
       
    77             Instant end = null;
       
    78             for (RecordedEvent e : RecordingFile.readAllEvents(p)) {
       
    79                 if (e.getBoolean("before")) {
       
    80                     start = e.getStartTime();
       
    81                     System.out.println("Start: " + start);
       
    82                 }
       
    83                 if (!e.getBoolean("before")) {
       
    84                     end = e.getStartTime();
       
    85                     System.out.println("End  : " + end);
       
    86                 }
       
    87             }
       
    88 
    70             AtomicBoolean error = new AtomicBoolean(true);
    89             AtomicBoolean error = new AtomicBoolean(true);
    71             try (EventStream d = EventStream.openRepository()) {
    90             try (EventStream d = EventStream.openRepository()) {
    72                 d.setStartTime(start); // needed so we don't start after end time
    91                 d.setStartTime(start);
    73                 d.setEndTime(end);
    92                 d.setEndTime(end);
    74                 d.onEvent(e -> {
    93                 d.onEvent(e -> {
    75                     System.out.println(e);
    94                     System.out.println(e);
       
    95                     System.out.println("Event:");
       
    96                     System.out.println(e.getStartTime());
       
    97                     System.out.println(e.getEndTime());
       
    98                     System.out.println(e.getBoolean("before"));
       
    99                     System.out.println();
    76                     boolean before = e.getBoolean("before");
   100                     boolean before = e.getBoolean("before");
    77                     if (before) {
   101                     if (before) {
    78                         error.set(false);
   102                         error.set(false);
    79                     } else {
   103                     } else {
    80                         error.set(true);
   104                         error.set(true);
    85                     throw new Exception("Found unexpected event!");
   109                     throw new Exception("Found unexpected event!");
    86                 }
   110                 }
    87             }
   111             }
    88         }
   112         }
    89     }
   113     }
       
   114 
       
   115     private static void advanceClock() {
       
   116         // Wait for some clock movement with
       
   117         // java.time clock resolution.
       
   118         Instant now = Instant.now();
       
   119         while (Instant.now().equals(now)) {
       
   120         }
       
   121     }
    90 }
   122 }