clang-format runtime/vm

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 {
 
 #ifndef PRODUCT
 
 class TimelineRecorderOverride : public ValueObject {
  public:
   explicit TimelineRecorderOverride(TimelineEventRecorder* new_recorder)
       : recorder_(Timeline::recorder()) {
     Timeline::recorder_ = new_recorder;
   }
 
-  ~TimelineRecorderOverride() {
-    Timeline::recorder_ = 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) {
+  static void FakeThreadEvent(TimelineEventBlock* block,
+                              intptr_t ftid,
+                              const char* label = "fake",
+                              TimelineStream* stream = NULL) {
     TimelineEvent* event = block->StartEvent();
     ASSERT(event != NULL);
     event->DurationBegin(label);
     event->thread_ = OSThread::ThreadIdFromIntPtr(ftid);
     if (stream != NULL) {
       event->StreamInit(stream);
     }
   }
 
-  static void SetBlockThread(TimelineEventBlock* block,
-                             intptr_t ftid) {
+  static void SetBlockThread(TimelineEventBlock* block, intptr_t ftid) {
     block->thread_id_ = OSThread::ThreadIdFromIntPtr(ftid);
   }
 
-  static void FakeDuration(
-      TimelineEventRecorder* recorder,
-      const char* label,
-      int64_t start,
-      int64_t end) {
+  static void FakeDuration(TimelineEventRecorder* recorder,
+                           const char* label,
+                           int64_t start,
+                           int64_t end) {
     ASSERT(recorder != NULL);
     ASSERT(start < end);
     ASSERT(label != NULL);
     TimelineEvent* event = recorder->StartEvent();
     ASSERT(event != NULL);
     event->Duration(label, start, end);
     event->Complete();
   }
 
-  static void FakeBegin(
-      TimelineEventRecorder* recorder,
-      const char* label,
-      int64_t start) {
+  static void FakeBegin(TimelineEventRecorder* recorder,
+                        const char* label,
+                        int64_t start) {
     ASSERT(recorder != NULL);
     ASSERT(label != NULL);
     ASSERT(start >= 0);
     TimelineEvent* event = recorder->StartEvent();
     ASSERT(event != NULL);
     event->Begin(label, start);
     event->Complete();
   }
 
-  static void FakeEnd(
-      TimelineEventRecorder* recorder,
-      const char* label,
-      int64_t end) {
+  static void FakeEnd(TimelineEventRecorder* recorder,
+                      const char* label,
+                      int64_t end) {
     ASSERT(recorder != NULL);
     ASSERT(label != NULL);
     ASSERT(end >= 0);
     TimelineEvent* event = recorder->StartEvent();
     ASSERT(event != NULL);
     event->End(label, end);
     event->Complete();
   }
 
   static void Clear(TimelineEventEndlessRecorder* recorder) {
     ASSERT(recorder != NULL);
     recorder->Clear();
   }
 
-  static void FinishBlock(TimelineEventBlock* block) {
-    block->Finish();
-  }
+  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);
@@ skipping 163 matching lines @@
 
 // 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()]++;
-  }
+  void OnEvent(TimelineEvent* event) { counts_[event->event_type()]++; }
 
-  intptr_t CountFor(TimelineEvent::EventType type) {
-    return counts_[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;
+  for (intptr_t i = TimelineEvent::kNone + 1; i < TimelineEvent::kNumEventTypes;
        i++) {
     EXPECT_EQ(0, recorder->CountFor(static_cast<TimelineEvent::EventType>(i)));
   }
 
   // Create a test stream.
   TimelineStream stream;
   stream.Init("testStream", true);
 
   TimelineEvent* event = NULL;
 
@@ skipping 574 matching lines @@
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(pauses.has_error());
   }
   TimelineTestHelper::Clear(recorder);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart