VM: Re-format to use at most one newline between functions

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 12 matching lines @@
       : recorder_(Timeline::recorder()) {
     Timeline::recorder_ = new_recorder;
   }
 
   ~TimelineRecorderOverride() { Timeline::recorder_ = recorder_; }
 
  private:
   TimelineEventRecorder* recorder_;
 };
 
-
 class TimelineTestHelper : public AllStatic {
  public:
   static void SetStream(TimelineEvent* event, TimelineStream* stream) {
     event->StreamInit(stream);
   }
 
   static void FakeThreadEvent(TimelineEventBlock* block,
                               intptr_t ftid,
                               const char* label = "fake",
                               TimelineStream* stream = NULL) {
@@ skipping 48 matching lines @@
   }
 
   static void Clear(TimelineEventRecorder* recorder) {
     ASSERT(recorder != NULL);
     recorder->Clear();
   }
 
   static void FinishBlock(TimelineEventBlock* block) { block->Finish(); }
 };
 
-
 TEST_CASE(TimelineEventIsValid) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   TimelineEvent event;
   TimelineTestHelper::SetStream(&event, &stream);
 
   // Starts invalid.
   EXPECT(!event.IsValid());
 
   // Becomes valid.
   event.Instant("hello");
   EXPECT(event.IsValid());
 
   // Becomes invalid.
   event.Reset();
   EXPECT(!event.IsValid());
 }
 
-
 TEST_CASE(TimelineEventDuration) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   // Create a test event.
   TimelineEvent event;
   TimelineTestHelper::SetStream(&event, &stream);
   event.DurationBegin("apple");
   // Measure the duration.
   int64_t current_duration = event.TimeDuration();
   event.DurationEnd();
   // Verify that duration is larger.
   EXPECT_GE(event.TimeDuration(), current_duration);
 }
 
-
 TEST_CASE(TimelineEventDurationPrintJSON) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   // Create a test event.
   TimelineEvent event;
   TimelineTestHelper::SetStream(&event, &stream);
   event.DurationBegin("apple");
   {
     // Test printing to JSON.
     JSONStream js;
     event.PrintJSON(&js);
     // Check category
     EXPECT_SUBSTRING("\"cat\":\"testStream\"", js.ToCString());
     // Check name.
     EXPECT_SUBSTRING("\"name\":\"apple\"", js.ToCString());
     // Check phase.
     EXPECT_SUBSTRING("\"ph\":\"X\"", js.ToCString());
     // Check that ts key is present.
     EXPECT_SUBSTRING("\"ts\":", js.ToCString());
     // Check that dur key is present.
     EXPECT_SUBSTRING("\"dur\":", js.ToCString());
   }
   event.DurationEnd();
 }
 
-
 TEST_CASE(TimelineEventPrintSystrace) {
   const intptr_t kBufferLength = 1024;
   char buffer[kBufferLength];
 
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   // Create a test event.
   TimelineEvent event;
@@ skipping 23 matching lines @@
   EXPECT_SUBSTRING("C|", buffer);
   EXPECT_SUBSTRING("|CTR|4", buffer);
 
   // Test a duration event. This event kind is not supported so we should
   // serialize it to an empty string.
   event.Duration("DUR", 0, 1, 2, 3);
   event.PrintSystrace(&buffer[0], kBufferLength);
   EXPECT_STREQ("", buffer);
 }
 
-
 TEST_CASE(TimelineEventArguments) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   // Create a test event.
   TimelineEvent event;
   TimelineTestHelper::SetStream(&event, &stream);
 
   // Allocate room for four arguments.
   event.SetNumArguments(4);
   // Reset.
   event.Reset();
 
   event.DurationBegin("apple");
   event.SetNumArguments(2);
   event.CopyArgument(0, "arg1", "value1");
   event.CopyArgument(1, "arg2", "value2");
   event.DurationEnd();
 }
 
-
 TEST_CASE(TimelineEventArgumentsPrintJSON) {
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   // Create a test event.
   TimelineEvent event;
   TimelineTestHelper::SetStream(&event, &stream);
 
   event.DurationBegin("apple");
   event.SetNumArguments(2);
   event.CopyArgument(0, "arg1", "value1");
   event.CopyArgument(1, "arg2", "value2");
   event.DurationEnd();
 
   {
     // Test printing to JSON.
     JSONStream js;
     event.PrintJSON(&js);
 
     // Check both arguments.
     EXPECT_SUBSTRING("\"arg1\":\"value1\"", js.ToCString());
     EXPECT_SUBSTRING("\"arg2\":\"value2\"", js.ToCString());
   }
 }
 
-
 TEST_CASE(TimelineEventBufferPrintJSON) {
   TimelineEventRecorder* recorder = Timeline::recorder();
   JSONStream js;
   TimelineEventFilter filter;
   recorder->PrintJSON(&js, &filter);
   // Check the type. This test will fail if we ever make Timeline public.
   EXPECT_SUBSTRING("\"type\":\"_Timeline\"", js.ToCString());
   // Check that there is a traceEvents array.
   EXPECT_SUBSTRING("\"traceEvents\":[", js.ToCString());
 }
 
-
 // Count the number of each event type seen.
 class EventCounterRecorder : public TimelineEventCallbackRecorder {
  public:
   EventCounterRecorder() {
     for (intptr_t i = 0; i < TimelineEvent::kNumEventTypes; i++) {
       counts_[i] = 0;
     }
   }
 
   void OnEvent(TimelineEvent* event) { counts_[event->event_type()]++; }
 
   intptr_t CountFor(TimelineEvent::EventType type) { return counts_[type]; }
 
  private:
   intptr_t counts_[TimelineEvent::kNumEventTypes];
 };
 
-
 TEST_CASE(TimelineEventCallbackRecorderBasic) {
   EventCounterRecorder* recorder = new EventCounterRecorder();
   TimelineRecorderOverride override(recorder);
 
   // Initial counts are all zero.
   for (intptr_t i = TimelineEvent::kNone + 1; i < TimelineEvent::kNumEventTypes;
        i++) {
     EXPECT_EQ(0, recorder->CountFor(static_cast<TimelineEvent::EventType>(i)));
   }
 
@@ skipping 38 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));
 
   delete recorder;
 }
 
-
 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();
   TimelineTestHelper::SetBlockThread(block_1_0, 1);
   TimelineEventBlock* block_1_1 = recorder->GetNewBlock();
   TimelineTestHelper::SetBlockThread(block_1_1, 1);
   TimelineEventBlock* block_1_2 = recorder->GetNewBlock();
   TimelineTestHelper::SetBlockThread(block_1_2, 1);
@@ skipping 99 matching lines @@
     EXPECT(LabelMatch(it.Next(), "E"));
     EXPECT(it.HasNext());
     EXPECT(LabelMatch(it.Next(), "F"));
     EXPECT(!it.HasNext());
   }
 
   TimelineTestHelper::Clear(recorder);
   delete recorder;
 }
 
-
 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();
@@ skipping 18 matching lines @@
   // 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);
 
   TimelineTestHelper::Clear(recorder);
   delete recorder;
 }
 
-
 TEST_CASE(TimelinePauses_Basic) {
   TimelineEventEndlessRecorder* recorder = new TimelineEventEndlessRecorder();
   ASSERT(recorder != NULL);
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   ThreadId tid = os_thread->trace_id();
 
   // Test case.
@@ skipping 153 matching lines @@
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(10, pauses.ExclusiveTime("a"));
     EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
     EXPECT_EQ(8, pauses.MaxExclusiveTime("a"));
   }
   TimelineTestHelper::Clear(recorder);
 
   delete recorder;
 }
 
-
 TEST_CASE(TimelinePauses_BeginEnd) {
   TimelineEventEndlessRecorder* recorder = new TimelineEventEndlessRecorder();
   ASSERT(recorder != NULL);
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   OSThread* os_thread = thread->os_thread();
   ASSERT(os_thread != NULL);
   ThreadId tid = os_thread->trace_id();
 
   // Test case.
@@ skipping 194 matching lines @@
     EXPECT(pauses.has_error());
   }
   TimelineTestHelper::Clear(recorder);
 
   delete recorder;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart