Improve timeline iterators and tests

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"
@@ skipping 226 matching lines @@
 
   event = stream.StartEvent();
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kAsyncEnd));
   event->AsyncEnd("asyncEndCabbage", async_id);
   EXPECT_EQ(0, recorder->CountFor(TimelineEvent::kAsyncEnd));
   event->Complete();
   EXPECT_EQ(1, recorder->CountFor(TimelineEvent::kAsyncEnd));
 }
 
 
+static bool LabelMatch(TimelineEvent* event, const char* label) {
+  ASSERT(event != NULL);
+  return strcmp(event->label(), label) == 0;
+}
+
+
 TEST_CASE(TimelineAnalysis_ThreadBlockCount) {
   TimelineEventEndlessRecorder* recorder = new TimelineEventEndlessRecorder();
   ASSERT(recorder != NULL);
   // Blocks owned by thread "1".
   TimelineEventBlock* block_1_0 = recorder->GetNewBlock();
   TimelineEventBlock* block_1_1 = recorder->GetNewBlock();
   TimelineEventBlock* block_1_2 = recorder->GetNewBlock();
   // Blocks owned by thread "2".
   TimelineEventBlock* block_2_0 = recorder->GetNewBlock();
   // Blocks owned by thread "3".
   TimelineEventBlock* block_3_0 = recorder->GetNewBlock();
   USE(block_3_0);
 
   // Add events to each block for thread 1.
-  TimelineTestHelper::FakeThreadEvent(block_1_2, 1);
-  TimelineTestHelper::FakeThreadEvent(block_1_2, 1);
-  TimelineTestHelper::FakeThreadEvent(block_1_2, 1);
+  TimelineTestHelper::FakeThreadEvent(block_1_2, 1, "B1");
+  TimelineTestHelper::FakeThreadEvent(block_1_2, 1, "B2");
+  TimelineTestHelper::FakeThreadEvent(block_1_2, 1, "B3");
   // Sleep to ensure timestamps differ.
   OS::Sleep(1);
-  TimelineTestHelper::FakeThreadEvent(block_1_0, 1);
+  TimelineTestHelper::FakeThreadEvent(block_1_0, 1, "A1");
   OS::Sleep(1);
-  TimelineTestHelper::FakeThreadEvent(block_1_1, 1);
-  TimelineTestHelper::FakeThreadEvent(block_1_1, 1);
+  TimelineTestHelper::FakeThreadEvent(block_1_1, 1, "C1");
+  TimelineTestHelper::FakeThreadEvent(block_1_1, 1, "C2");
   OS::Sleep(1);
 
   // Add events to each block for thread 2.
-  TimelineTestHelper::FakeThreadEvent(block_2_0, 2);
-  TimelineTestHelper::FakeThreadEvent(block_2_0, 2);
-  TimelineTestHelper::FakeThreadEvent(block_2_0, 2);
-  TimelineTestHelper::FakeThreadEvent(block_2_0, 2);
-  TimelineTestHelper::FakeThreadEvent(block_2_0, 2);
-  TimelineTestHelper::FakeThreadEvent(block_2_0, 2);
+  TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "A");
+  TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "B");
+  TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "C");
+  TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "D");
+  TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "E");
+  TimelineTestHelper::FakeThreadEvent(block_2_0, 2, "F");
 
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
 
   // Discover threads in recorder.
   TimelineAnalysis ta(zone, isolate, recorder);
   ta.BuildThreads();
   // block_3_0 is never used by a thread, so we only have two threads.
   EXPECT_EQ(2, ta.NumThreads());
@@ skipping 21 matching lines @@
   EXPECT_EQ(1, block_1_0->length());
 
   // 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());
+
+  {
+    TimelineAnalysisThreadEventIterator it(thread_1);
+    // Six events spread across three blocks.
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "B1"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "B2"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "B3"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "A1"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "C1"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "C2"));
+    EXPECT(!it.HasNext());
+  }
+
+  {
+    TimelineAnalysisThreadEventIterator it(thread_2);
+    // Six events spread across three blocks.
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "A"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "B"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "C"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "D"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "E"));
+    EXPECT(it.HasNext());
+    EXPECT(LabelMatch(it.Next(), "F"));
+    EXPECT(!it.HasNext());
+  }
 }
 
 
 TEST_CASE(TimelineRingRecorderJSONOrder) {
   TimelineStream stream;
   stream.Init("testStream", true);
 
   TimelineEventRingRecorder* recorder =
       new TimelineEventRingRecorder(TimelineEventBlock::kBlockSize * 2);
 
@@ skipping 15 matching lines @@
   // 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