stopwatch: auto_start option, make pause cumulative

vlib/time/stopwatch.v

@@ -3,50 +3,65 @@
 // that can be found in the LICENSE file.
 module time
 
-pub struct StopWatch {
-mut:
-	pause_time u64
-pub mut:
-	start      u64
-	end        u64
+pub struct StopWatchOptions {
+	auto_start bool = true
 }
 
-pub fn new_stopwatch() StopWatch {
-	return StopWatch{pause_time: 0, start: time.sys_mono_now(), end: 0}
+pub struct StopWatch {
+mut:
+	elapsed u64
+pub mut:
+	start   u64
+	end     u64
+}
+
+pub fn new_stopwatch(opts StopWatchOptions) StopWatch {
+	mut initial := u64(0)
+
+	if opts.auto_start {
+		initial = time.sys_mono_now()
+	}
+
+	return StopWatch{elapsed: 0, start: initial, end: 0}
 }
 
 // start Starts the timer. If the timer was paused, restarts counting.
 pub fn (mut t StopWatch) start() {
-	if t.pause_time == 0 {
-		t.start = time.sys_mono_now()
-	} else {
-		t.start += time.sys_mono_now() - t.pause_time
-	}
+	t.start = time.sys_mono_now()
 	t.end = 0
-	t.pause_time = 0
 }
 
 pub fn (mut t StopWatch) restart() {
-	t.end = 0
-	t.pause_time = 0
 	t.start = time.sys_mono_now()
+	t.end = 0
+	t.elapsed = 0
 }
 
 pub fn (mut t StopWatch) stop() {
 	t.end = time.sys_mono_now()
-	t.pause_time = 0
 }
 
 pub fn (mut t StopWatch) pause() {
-	t.pause_time = time.sys_mono_now()
-	t.end = t.pause_time // so elapsed keeps track of actual running time
+	if t.start > 0 {
+		if t.end == 0 {
+			t.elapsed += time.sys_mono_now() - t.start
+		} else {
+			t.elapsed += t.end - t.start
+		}
+	}
+
+	t.start = 0
 }
 
 // elapsed returns the Duration since the last start call
 pub fn (t StopWatch) elapsed() Duration {
-	if t.end == 0 {
-		return Duration(time.sys_mono_now() - t.start)
-	} else {
-		return Duration(t.end - t.start)
+	if t.start > 0 {
+		if t.end == 0 {
+			return Duration(time.sys_mono_now() - t.start + t.elapsed)
+		} else {
+			return Duration(t.end - t.start + t.elapsed)
+		}
 	}
+
+	return Duration(t.elapsed)
 }

vlib/time/stopwatch_test.v

@@ -4,7 +4,7 @@ import time
 // time than you have specified. To avoid false positives from CI test
 // failures, some of the asserts will be run only if you pass `-d stopwatch`
 fn test_stopwatch_works_as_intended() {
-	sw := time.new_stopwatch()
+	sw := time.new_stopwatch({})
 	// sample code that you want to measure:
 	println('Hello world')
 	time.sleep_ms(1)
@@ -14,20 +14,21 @@ fn test_stopwatch_works_as_intended() {
 }
 
 fn test_stopwatch_time_between_pause_and_start_should_be_skipped_in_elapsed() {
-	sw := time.new_stopwatch()
+	println('Testing pause function')
+	sw := time.new_stopwatch({})
 	time.sleep_ms(10) // A
-	// eprintln('${sw.elapsed().milliseconds()}ms')
+	eprintln('Elapsed after 10ms nap: ${sw.elapsed().milliseconds()}ms')
 	assert sw.elapsed().milliseconds() >= 10
 	sw.pause()
 	time.sleep_ms(10)
-	// eprintln('${sw.elapsed().milliseconds()}ms')
+	eprintln('Elapsed after pause and another 10ms nap: ${sw.elapsed().milliseconds()}ms')
 	assert sw.elapsed().milliseconds() >= 10
 	$if stopwatch ? {
 		assert sw.elapsed().milliseconds() < 20
 	}
 	sw.start()
 	time.sleep_ms(10) // B
-	// Here, sw.elapsed() should be ~10ms (from A) + ~10ms (from B) >= 20ms
+	eprintln('Elapsed after resume and another 10ms nap: ${sw.elapsed().milliseconds()}ms')
 	assert sw.elapsed().milliseconds() >= 20
 	$if stopwatch ? {
 		assert sw.elapsed().milliseconds() < 30