Clang format slam.

net/url_request/url_request_throttler_simulation_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The tests in this file attempt to verify the following through simulation:
 // a) That a server experiencing overload will actually benefit from the
 //    anti-DDoS throttling logic, i.e. that its traffic spike will subside
 //    and be distributed over a longer period of time;
 // b) That "well-behaved" clients of a server under DDoS attack actually
 //    benefit from the anti-DDoS throttling logic; and
@@ skipping 59 matching lines @@
     virtual void AdvanceTime(const TimeTicks& absolute_time) = 0;
     virtual void PerformAction() = 0;
   };
 
   DiscreteTimeSimulation() {}
 
   // Adds an |actor| to the simulation. The client of the simulation maintains
   // ownership of |actor| and must ensure its lifetime exceeds that of the
   // simulation. Actors should be added in the order you wish for them to
   // act at each tick of the simulation.
-  void AddActor(Actor* actor) {
-    actors_.push_back(actor);
-  }
+  void AddActor(Actor* actor) { actors_.push_back(actor); }
 
   // Runs the simulation for, pretending |time_between_ticks| passes from one
   // tick to the next. The start time will be the current real time. The
   // simulation will stop when the simulated duration is equal to or greater
   // than |maximum_simulated_duration|.
   void RunSimulation(const TimeDelta& maximum_simulated_duration,
                      const TimeDelta& time_between_ticks) {
     TimeTicks start_time = TimeTicks();
     TimeTicks now = start_time;
     while ((now - start_time) <= maximum_simulated_duration) {
@@ skipping 58 matching lines @@
     }
 
     requests_per_tick_.push_back(num_current_tick_queries_);
     num_current_tick_queries_ = 0;
   }
 
   // This is called by Requester. It returns the response code from
   // the server.
   int HandleRequest() {
     ++num_current_tick_queries_;
-    if (!start_downtime_.is_null() &&
-        start_downtime_ < now_ && now_ < end_downtime_) {
+    if (!start_downtime_.is_null() && start_downtime_ < now_ &&
+        now_ < end_downtime_) {
       // For the simulation measuring the increase in perceived
       // downtime, it might be interesting to count separately the
       // queries seen by the server (assuming a front-end reverse proxy
       // is what actually serves up the 503s in this case) so that we could
       // visualize the traffic spike seen by the server when it comes up,
       // which would in many situations be ameliorated by the anti-DDoS
       // throttling.
       return 503;
     }
 
     if ((num_overloaded_ticks_remaining_ > 0 ||
          num_current_tick_queries_ > max_queries_per_tick_) &&
         base::RandDouble() < request_drop_ratio_) {
       return 503;
     }
 
     return 200;
   }
 
-  int num_overloaded_ticks() const {
-    return num_overloaded_ticks_;
-  }
+  int num_overloaded_ticks() const { return num_overloaded_ticks_; }
 
   int max_experienced_queries_per_tick() const {
     return max_experienced_queries_per_tick_;
   }
 
-  const URLRequest& mock_request() const {
-    return mock_request_;
-  }
+  const URLRequest& mock_request() const { return mock_request_; }
 
   std::string VisualizeASCII(int terminal_width) {
     // Account for | characters we place at left of graph.
     terminal_width -= 1;
 
     VerboseOut("Overloaded for %d of %d ticks.\n",
-               num_overloaded_ticks_, requests_per_tick_.size());
+               num_overloaded_ticks_,
+               requests_per_tick_.size());
     VerboseOut("Got maximum of %d requests in a tick.\n\n",
                max_experienced_queries_per_tick_);
 
     VerboseOut("Traffic graph:\n\n");
 
     // Printing the graph like this is a bit overkill, but was very useful
     // while developing the various simulations to see if they were testing
     // the corner cases we want to simulate.
 
     // Find the smallest number of whole ticks we need to group into a
@@ skipping 91 matching lines @@
         mock_backoff_entry_(&backoff_policy_) {}
 
   virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE {
     return &mock_backoff_entry_;
   }
 
   virtual BackoffEntry* GetBackoffEntry() OVERRIDE {
     return &mock_backoff_entry_;
   }
 
-  virtual TimeTicks ImplGetTimeNow() const OVERRIDE {
-    return fake_now_;
-  }
+  virtual TimeTicks ImplGetTimeNow() const OVERRIDE { return fake_now_; }
 
   void SetFakeNow(const TimeTicks& fake_time) {
     fake_now_ = fake_time;
     mock_backoff_entry_.set_fake_now(fake_time);
   }
 
-  TimeTicks fake_now() const {
-    return fake_now_;
-  }
+  TimeTicks fake_now() const { return fake_now_; }
 
  protected:
   virtual ~MockURLRequestThrottlerEntry() {}
 
  private:
   TimeTicks fake_now_;
   MockBackoffEntry mock_backoff_entry_;
 };
 
 // Registry of results for a class of |Requester| objects (e.g. attackers vs.
 // regular clients).
 class RequesterResults {
-public:
+ public:
   RequesterResults()
-      : num_attempts_(0), num_successful_(0), num_failed_(0), num_blocked_(0) {
-  }
+      : num_attempts_(0), num_successful_(0), num_failed_(0), num_blocked_(0) {}
 
   void AddSuccess() {
     ++num_attempts_;
     ++num_successful_;
   }
 
   void AddFailure() {
     ++num_attempts_;
     ++num_failed_;
   }
 
   void AddBlocked() {
     ++num_attempts_;
     ++num_blocked_;
   }
 
   int num_attempts() const { return num_attempts_; }
   int num_successful() const { return num_successful_; }
   int num_failed() const { return num_failed_; }
   int num_blocked() const { return num_blocked_; }
 
   double GetBlockedRatio() {
     DCHECK(num_attempts_);
     return static_cast<double>(num_blocked_) /
-        static_cast<double>(num_attempts_);
+           static_cast<double>(num_attempts_);
   }
 
   double GetSuccessRatio() {
     DCHECK(num_attempts_);
     return static_cast<double>(num_successful_) /
-        static_cast<double>(num_attempts_);
+           static_cast<double>(num_attempts_);
   }
 
   void PrintResults(const char* class_description) {
     if (num_attempts_ == 0) {
       VerboseOut("No data for %s\n", class_description);
       return;
     }
 
     VerboseOut("Requester results for %s\n", class_description);
     VerboseOut("  %d attempts\n", num_attempts_);
@@ skipping 76 matching lines @@
 
       time_of_last_attempt_ = throttler_entry_->fake_now();
     }
   }
 
   // Adds a delay until the first request, equal to a uniformly distributed
   // value between now and now + max_delay.
   void SetStartupJitter(const TimeDelta& max_delay) {
     int delay_ms = base::RandInt(0, max_delay.InMilliseconds());
     time_of_last_attempt_ = TimeTicks() +
-        TimeDelta::FromMilliseconds(delay_ms) - time_between_requests_;
+                            TimeDelta::FromMilliseconds(delay_ms) -
+                            time_between_requests_;
   }
 
   void SetRequestJitter(const TimeDelta& request_jitter) {
     request_jitter_ = request_jitter;
   }
 
   TimeDelta last_downtime_duration() const { return last_downtime_duration_; }
 
  private:
   scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry_;
@@ skipping 19 matching lines @@
   URLRequestThrottlerManager manager;
   ScopedVector<Requester> requesters;
   for (size_t i = 0; i < kNumAttackers; ++i) {
     // Use a tiny time_between_requests so the attackers will ping the
     // server at every tick of the simulation.
     scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
         new MockURLRequestThrottlerEntry(&manager));
     if (!enable_throttling)
       throttler_entry->DisableBackoffThrottling();
 
-      Requester* attacker = new Requester(throttler_entry.get(),
+    Requester* attacker = new Requester(throttler_entry.get(),
                                         TimeDelta::FromMilliseconds(1),
                                         server,
                                         attacker_results);
     attacker->SetStartupJitter(TimeDelta::FromSeconds(120));
     requesters.push_back(attacker);
     simulation.AddActor(attacker);
   }
   for (size_t i = 0; i < kNumClients; ++i) {
     // Normal clients only make requests every 2 minutes, plus/minus 1 minute.
     scoped_refptr<MockURLRequestThrottlerEntry> throttler_entry(
@@ skipping 90 matching lines @@
   requester.SetStartupJitter(duration / 3);
   requester.SetRequestJitter(average_client_interval);
 
   DiscreteTimeSimulation simulation;
   simulation.AddActor(&requester);
   simulation.AddActor(&server);
 
   simulation.RunSimulation(duration * 2, time_between_ticks);
 
   return static_cast<double>(
-      requester.last_downtime_duration().InMilliseconds()) /
-      static_cast<double>(duration.InMilliseconds());
+             requester.last_downtime_duration().InMilliseconds()) /
+         static_cast<double>(duration.InMilliseconds());
 }
 
 TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
   struct Stats {
     // Expected interval that we expect the ratio of downtime when anti-DDoS
     // is enabled and downtime when anti-DDoS is not enabled to fall within.
     //
     // The expected interval depends on two things:  The exponential back-off
     // policy encoded in URLRequestThrottlerEntry, and the test or set of
     // tests that the Stats object is tracking (e.g. a test where the client
@@ skipping 13 matching lines @@
     double total_ratio_unprotected;
     double total_ratio_protected;
 
     bool DidConverge(double* increase_ratio_out) {
       double unprotected_ratio = total_ratio_unprotected / num_runs;
       double protected_ratio = total_ratio_protected / num_runs;
       double increase_ratio = protected_ratio / unprotected_ratio;
       if (increase_ratio_out)
         *increase_ratio_out = increase_ratio;
       return expected_min_increase <= increase_ratio &&
-          increase_ratio <= expected_max_increase;
+             increase_ratio <= expected_max_increase;
     }
 
     void ReportTrialResult(double increase_ratio) {
       VerboseOut(
           "  Perceived downtime with throttling is %.4f times without.\n",
           increase_ratio);
       VerboseOut("  Test result after %d trials.\n", num_runs);
     }
   };
 
-  Stats global_stats = { 1.08, 1.15 };
+  Stats global_stats = {1.08, 1.15};
 
   struct Trial {
     TimeDelta duration;
     TimeDelta average_client_interval;
     Stats stats;
 
     void PrintTrialDescription() {
       double duration_minutes =
           static_cast<double>(duration.InSeconds()) / 60.0;
       double interval_minutes =
           static_cast<double>(average_client_interval.InSeconds()) / 60.0;
       VerboseOut("Trial with %.2f min downtime, avg. interval %.2f min.\n",
-                 duration_minutes, interval_minutes);
+                 duration_minutes,
+                 interval_minutes);
     }
   };
 
   // We don't set or check expected ratio intervals on individual
   // experiments as this might make the test too fragile, but we
   // print them out at the end for manual evaluation (we want to be
   // able to make claims about the expected ratios depending on the
   // type of behavior of the client and the downtime, e.g. the difference
   // in behavior between a client making requests every few minutes vs.
   // one that makes a request every 15 seconds).
   Trial trials[] = {
-    { TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(3) },
-    { TimeDelta::FromSeconds(30), TimeDelta::FromSeconds(7) },
-    { TimeDelta::FromMinutes(5), TimeDelta::FromSeconds(30) },
-    { TimeDelta::FromMinutes(10), TimeDelta::FromSeconds(20) },
-    { TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(15) },
-    { TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(50) },
-    { TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(2) },
-    { TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(5) },
-    { TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(7) },
-    { TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(2) },
-    { TimeDelta::FromMinutes(40), TimeDelta::FromSeconds(15) },
-    { TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(7) },
-    { TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(2) },
-    { TimeDelta::FromMinutes(60), TimeDelta::FromSeconds(15) },
-    { TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(20) },
-    { TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(3) },
-    { TimeDelta::FromMinutes(80), TimeDelta::FromSeconds(15) },
+      {TimeDelta::FromSeconds(10), TimeDelta::FromSeconds(3)},
+      {TimeDelta::FromSeconds(30), TimeDelta::FromSeconds(7)},
+      {TimeDelta::FromMinutes(5), TimeDelta::FromSeconds(30)},
+      {TimeDelta::FromMinutes(10), TimeDelta::FromSeconds(20)},
+      {TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(15)},
+      {TimeDelta::FromMinutes(20), TimeDelta::FromSeconds(50)},
+      {TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(2)},
+      {TimeDelta::FromMinutes(30), TimeDelta::FromMinutes(5)},
+      {TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(7)},
+      {TimeDelta::FromMinutes(40), TimeDelta::FromMinutes(2)},
+      {TimeDelta::FromMinutes(40), TimeDelta::FromSeconds(15)},
+      {TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(7)},
+      {TimeDelta::FromMinutes(60), TimeDelta::FromMinutes(2)},
+      {TimeDelta::FromMinutes(60), TimeDelta::FromSeconds(15)},
+      {TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(20)},
+      {TimeDelta::FromMinutes(80), TimeDelta::FromMinutes(3)},
+      {TimeDelta::FromMinutes(80), TimeDelta::FromSeconds(15)},
 
-    // Most brutal?
-    { TimeDelta::FromMinutes(45), TimeDelta::FromMilliseconds(500) },
+      // Most brutal?
+      {TimeDelta::FromMinutes(45), TimeDelta::FromMilliseconds(500)},
   };
 
   // If things don't converge by the time we've done 100K trials, then
   // clearly one or more of the expected intervals are wrong.
   while (global_stats.num_runs < 100000) {
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(trials); ++i) {
       ++global_stats.num_runs;
       ++trials[i].stats.num_runs;
       double ratio_unprotected = SimulateDowntime(
           trials[i].duration, trials[i].average_client_interval, false);
@@ skipping 27 matching lines @@
     trials[i].PrintTrialDescription();
     trials[i].stats.ReportTrialResult(increase_ratio);
   }
 
   VerboseOut("Average increase ratio was %.4f\n", average_increase_ratio);
   VerboseOut("Maximum increase ratio was %.4f\n", max_increase_ratio);
 }
 
 }  // namespace
 }  // namespace net