Also switching the Vagrant file to use xenial since precise is past …

…it's EOL.

.

Vagrantfile

@@ -1,6 +1,5 @@
 Vagrant.configure("2") do |config|
-  config.vm.box = "precise32"
-  config.vm.box_url = "http://files.vagrantup.com/precise32.box"
+  config.vm.box = "ubuntu/xenial32"
   config.vm.network :forwarded_port, guest: 8089, host: 8089
   config.vm.provision :shell, :path => "examples/vagrant/vagrant.sh"
-end
+end

examples/vagrant/vagrant.sh

@@ -6,7 +6,7 @@
 
 # Update and install some dependencies
 apt-get -y update 
-apt-get -y install build-essential python-pip python-dev libev-dev libzmq-dev
+apt-get -y install build-essential python-pip python-dev libev-dev libzmq-dev supervisor
 cd /vagrant
 
 pip install --use-mirrors pyzmq supervisor
@@ -15,4 +15,4 @@ pip install --use-mirrors pyzmq supervisor
 python setup.py develop
 
 # Starting supervisor which is configured to start Locust
-supervisord -c examples/vagrant/supervisord.conf
+supervisord -c examples/vagrant/supervisord.conf

locust/stats.py

@@ -246,6 +246,14 @@ def _log_time_of_request(self, t):
 
     def _log_response_time(self, response_time):
 
+        self.total_response_time += response_time
+
+        if self.min_response_time is None:
+            self.min_response_time = response_time
+
+        self.min_response_time = min(self.min_response_time, response_time)
+        self.max_response_time = max(self.max_response_time, response_time)
+
         # to avoid to much data that has to be transfered to the master node when
         # running in distributed mode, we save the response time rounded in a dict
         # so that 147 becomes 150, 3432 becomes 3400 and 58760 becomes 59000
@@ -258,14 +266,6 @@ def _log_response_time(self, response_time):
         else:
             rounded_response_time = int(round(response_time, -3))
 
-        self.total_response_time += rounded_response_time
-
-        if self.min_response_time is None:
-            self.min_response_time = rounded_response_time
-
-        self.min_response_time = min(self.min_response_time, rounded_response_time)
-        self.max_response_time = max(self.max_response_time, rounded_response_time)
-
         # increase request count for the rounded key in response time dict
         self.response_times.setdefault(rounded_response_time, 0)
         self.response_times[rounded_response_time] += 1
@@ -461,7 +461,7 @@ def percentile(self, tpl=" %-" + str(STATS_NAME_WIDTH) + "s %8d %6d %6d %6d %6d
             self.get_response_time_percentile(0.95),
             self.get_response_time_percentile(0.98),
             self.get_response_time_percentile(0.99),
-            self.max_response_time
+            self.get_response_time_percentile(1.00)
         )
 
     def _cache_response_times(self, t):

locust/test/test_stats.py

@@ -53,7 +53,7 @@ def test_num_reqs_fails(self):
         self.assertEqual(self.s.num_failures, 3)
 
     def test_avg(self):
-        self.assertEqual(self.s.avg_response_time, 189.0)
+        self.assertEqual(self.s.avg_response_time, 187.71428571428572)
 
     def test_reset(self):
         self.s.reset()
@@ -64,13 +64,13 @@ def test_reset(self):
         self.assertEqual(self.s.total_rps, 2)
         self.assertEqual(self.s.num_requests, 2)
         self.assertEqual(self.s.num_failures, 1)
-        self.assertEqual(self.s.avg_response_time, 422.5)
+        self.assertEqual(self.s.avg_response_time, 420.5)
         self.assertEqual(self.s.median_response_time, 85)
 
     def test_reset_min_response_time(self):
         self.s.reset()
         self.s.log(756, 0)
-        self.assertEqual(760, self.s.min_response_time)
+        self.assertEqual(756, self.s.min_response_time)
 
     def test_aggregation(self):
         s1 = StatsEntry(self.stats, "aggregate me!", "GET")
@@ -112,16 +112,17 @@ def test_aggregation_with_rounding(self):
 
         self.assertEqual(s1.num_requests, 8)
         self.assertEqual(s1.median_response_time, 550)
-        self.assertEqual(s1.avg_response_time, 536.25)
-        self.assertEqual(s1.min_response_time, 120)
-        self.assertEqual(s1.max_response_time, 990)
+        self.assertEqual(s1.avg_response_time, 535.75)
+        self.assertEqual(s1.min_response_time, 122)
+        self.assertEqual(s1.max_response_time, 992)
 
-    def test_percentile_rounded(self):
+    def test_percentile_rounded_down(self):
         s1 = StatsEntry(self.stats, "rounding down!", "GET")
         s1.log(122, 0)    # (rounded 120) min
         actual_percentile = s1.percentile()
         self.assertEqual(actual_percentile, " GET rounding down!                                                  1    120    120    120    120    120    120    120    120    120")
 
+    def test_percentile_rounded_up(self):
         s2 = StatsEntry(self.stats, "rounding up!", "GET")
         s2.log(127, 0)    # (rounded 130) min
         actual_percentile = s2.percentile()