From 6b1043246380a5c543b8aba4b9ea11da8550cb25 Mon Sep 17 00:00:00 2001
From: Anton Kaliaev <anton.kalyaev@gmail.com>
Date: Tue, 23 May 2017 15:19:48 +0200
Subject: [PATCH 1/3] [flowrate] refactor clock functions (Refs #16)

this commit does not fix the original bug
---
 flowrate/util.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/flowrate/util.go b/flowrate/util.go
index 4caac583f..b33ddc701 100644
--- a/flowrate/util.go
+++ b/flowrate/util.go
@@ -15,16 +15,16 @@ const clockRate = 20 * time.Millisecond
 
 // czero is the process start time rounded down to the nearest clockRate
 // increment.
-var czero = time.Duration(time.Now().UnixNano()) / clockRate * clockRate
+var czero = time.Now().Round(clockRate)
 
 // clock returns a low resolution timestamp relative to the process start time.
 func clock() time.Duration {
-	return time.Duration(time.Now().UnixNano())/clockRate*clockRate - czero
+	return time.Now().Round(clockRate).Sub(czero)
 }
 
 // clockToTime converts a clock() timestamp to an absolute time.Time value.
 func clockToTime(c time.Duration) time.Time {
-	return time.Unix(0, int64(czero+c))
+	return czero.Add(c)
 }
 
 // clockRound returns d rounded to the nearest clockRate increment.

From b5c57967b71ed5c3c4667687df2a1e91317439b7 Mon Sep 17 00:00:00 2001
From: Anton Kaliaev <anton.kalyaev@gmail.com>
Date: Tue, 23 May 2017 15:24:00 +0200
Subject: [PATCH 2/3] [flowrate] improve error formatting (Refs #16)

---
 flowrate/io_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/flowrate/io_test.go b/flowrate/io_test.go
index fa7f4b4ae..f4049ed2a 100644
--- a/flowrate/io_test.go
+++ b/flowrate/io_test.go
@@ -91,7 +91,7 @@ func TestReader(t *testing.T) {
 	}
 	for i, s := range status {
 		if !reflect.DeepEqual(&s, &want[i]) {
-			t.Errorf("r.Status(%v) expected %v; got %v", i, want[i], s)
+			t.Errorf("r.Status(%v)\nexpected: %v\ngot     : %v", i, want[i], s)
 		}
 	}
 	if !bytes.Equal(b[:20], in[:20]) {
@@ -137,7 +137,7 @@ func TestWriter(t *testing.T) {
 	}
 	for i, s := range status {
 		if !reflect.DeepEqual(&s, &want[i]) {
-			t.Errorf("w.Status(%v) expected %v; got %v", i, want[i], s)
+			t.Errorf("w.Status(%v)\nexpected: %v\ngot     : %v\n", i, want[i], s)
 		}
 	}
 	if !bytes.Equal(b, w.Writer.(*bytes.Buffer).Bytes()) {

From 5f20b3323e6afa49eb7c681a953611af08f43206 Mon Sep 17 00:00:00 2001
From: Anton Kaliaev <anton.kalyaev@gmail.com>
Date: Thu, 25 May 2017 13:06:42 +0200
Subject: [PATCH 3/3] don't do DeepEqual, compare ranges for durations and
 rates (Refs #16)

---
 flowrate/io_test.go | 49 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 46 insertions(+), 3 deletions(-)

diff --git a/flowrate/io_test.go b/flowrate/io_test.go
index f4049ed2a..6d4934a8a 100644
--- a/flowrate/io_test.go
+++ b/flowrate/io_test.go
@@ -6,7 +6,6 @@ package flowrate
 
 import (
 	"bytes"
-	"reflect"
 	"testing"
 	"time"
 )
@@ -90,7 +89,7 @@ func TestReader(t *testing.T) {
 		Status{false, start, _300ms, 0, 20, 3, 0, 0, 67, 100, 0, 0, 0},
 	}
 	for i, s := range status {
-		if !reflect.DeepEqual(&s, &want[i]) {
+		if !statusesAreEqual(&s, &want[i]) {
 			t.Errorf("r.Status(%v)\nexpected: %v\ngot     : %v", i, want[i], s)
 		}
 	}
@@ -136,7 +135,7 @@ func TestWriter(t *testing.T) {
 		Status{true, start, _500ms, _100ms, 100, 5, 200, 200, 200, 200, 0, 0, 100000},
 	}
 	for i, s := range status {
-		if !reflect.DeepEqual(&s, &want[i]) {
+		if !statusesAreEqual(&s, &want[i]) {
 			t.Errorf("w.Status(%v)\nexpected: %v\ngot     : %v\n", i, want[i], s)
 		}
 	}
@@ -144,3 +143,47 @@ func TestWriter(t *testing.T) {
 		t.Errorf("w.Write() input doesn't match output")
 	}
 }
+
+const maxDeviationForDuration = 50 * time.Millisecond
+const maxDeviationForRate int64 = 50
+
+// statusesAreEqual returns true if s1 is equal to s2. Equality here means
+// general equality of fields except for the duration and rates, which can
+// drift due to unpredictable delays (e.g. thread wakes up 25ms after
+// `time.Sleep` has ended).
+func statusesAreEqual(s1 *Status, s2 *Status) bool {
+	if s1.Active == s2.Active &&
+		s1.Start == s2.Start &&
+		durationsAreEqual(s1.Duration, s2.Duration, maxDeviationForDuration) &&
+		s1.Idle == s2.Idle &&
+		s1.Bytes == s2.Bytes &&
+		s1.Samples == s2.Samples &&
+		ratesAreEqual(s1.InstRate, s2.InstRate, maxDeviationForRate) &&
+		ratesAreEqual(s1.CurRate, s2.CurRate, maxDeviationForRate) &&
+		ratesAreEqual(s1.AvgRate, s2.AvgRate, maxDeviationForRate) &&
+		ratesAreEqual(s1.PeakRate, s2.PeakRate, maxDeviationForRate) &&
+		s1.BytesRem == s2.BytesRem &&
+		durationsAreEqual(s1.TimeRem, s2.TimeRem, maxDeviationForDuration) &&
+		s1.Progress == s2.Progress {
+		return true
+	}
+	return false
+}
+
+func durationsAreEqual(d1 time.Duration, d2 time.Duration, maxDeviation time.Duration) bool {
+	if d2-d1 <= maxDeviation {
+		return true
+	}
+	return false
+}
+
+func ratesAreEqual(r1 int64, r2 int64, maxDeviation int64) bool {
+	sub := r1 - r2
+	if sub < 0 {
+		sub = -sub
+	}
+	if sub <= maxDeviation {
+		return true
+	}
+	return false
+}