Ensure TimelineEventRingRecorder outputs blocks in increasing time order

runtime/vm/timeline_test.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include <cstring>
+
 #include "platform/assert.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/globals.h"
 #include "vm/timeline.h"
 #include "vm/timeline_analysis.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 class TimelineTestHelper : public AllStatic {
  public:
   static void SetStream(TimelineEvent* event, TimelineStream* stream) {
     event->StreamInit(stream);
   }
 
   static TimelineEvent* FakeThreadEvent(
-      TimelineEventBlock* block, intptr_t ftid) {
+      TimelineEventBlock* block,
+      intptr_t ftid,
+      const char* label = "fake",
+      TimelineStream* stream = NULL) {
     TimelineEvent* event = block->StartEvent();
     ASSERT(event != NULL);
-    event->DurationBegin("fake");
+    event->DurationBegin(label);
     event->thread_ = OSThread::ThreadIdFromIntPtr(ftid);
+    if (stream != NULL) {
+      event->StreamInit(stream);
+    }
     return event;
   }
 };
 
 
 TEST_CASE(TimelineEventIsValid) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
@@ skipping 266 matching lines @@
   // Verify that block_1_1 has two events.
   EXPECT_EQ(2, block_1_1->length());
 
   // Thread '2" should have one block.'
   EXPECT_EQ(1, thread_2->NumBlocks());
   EXPECT_EQ(thread_2->At(0), block_2_0);
   // Verify that block_2_0 has six events.
   EXPECT_EQ(6, block_2_0->length());
 }
 
+
+TEST_CASE(TimelineRingRecorderJSONOrder) {
+  TimelineStream stream;
+  stream.Init("testStream", true);
+
+  TimelineEventRingRecorder* recorder =
+      new TimelineEventRingRecorder(TimelineEventBlock::kBlockSize * 2);
+
+  TimelineEventBlock* block_0 = recorder->GetNewBlock();
+  EXPECT(block_0 != NULL);
+  TimelineEventBlock* block_1 = recorder->GetNewBlock();
+  EXPECT(block_1 != NULL);
+  // Test that we wrapped.
+  EXPECT(block_0 == recorder->GetNewBlock());
+
+  // Emit the earlier event into block_1.
+  TimelineTestHelper::FakeThreadEvent(block_1, 2, "Alpha", &stream);
+  OS::Sleep(1);
+  // Emit the later event into block_0.
+  TimelineTestHelper::FakeThreadEvent(block_0, 2, "Beta", &stream);
+
+  JSONStream js;
+  recorder->PrintJSON(&js);
+  // trace-event has a requirement that events for a thread must have
+  // monotonically increasing timestamps.
+  // Verify that "Alpha" comes before "Beta" even though "Beta" is in the first
+  // block.
+  const char* alpha = strstr(js.ToCString(), "Alpha");
+  const char* beta = strstr(js.ToCString(), "Beta");
+  EXPECT(alpha < beta);
+}
+
 }  // namespace dart