Use generator

Author: ErikSchierboom

exercises/practice/split-second-stopwatch/.meta/Example.cs

@@ -0,0 +1,65 @@
+public enum StopwatchState
+{
+    Ready,
+    Running,
+    Stopped
+}
+
+public class SplitSecondStopwatch(TimeProvider time)
+{
+    private List<TimeSpan> _previousLaps = [];
+    private TimeSpan _currentLapTrackedTime = TimeSpan.Zero;
+    private DateTimeOffset? _currentLapTrackingTimeSince; 
+
+    private TimeSpan PreviousLapsTotal => _previousLaps.Aggregate(TimeSpan.Zero, (total, lap) => total + lap);
+    private TimeSpan CurrentLapTrackingTime =>
+        _currentLapTrackingTimeSince is null ? TimeSpan.Zero : time.GetUtcNow() - _currentLapTrackingTimeSince.Value;
+    
+    public StopwatchState State { get; private set; } = StopwatchState.Ready;
+    public TimeSpan CurrentLap => _currentLapTrackedTime + CurrentLapTrackingTime;
+    public TimeSpan Total => CurrentLap + PreviousLapsTotal;
+    public IReadOnlyCollection<TimeSpan> PreviousLaps => _previousLaps.AsReadOnly();
+
+    public void Start()
+    {
+        if (State == StopwatchState.Running)
+            throw new InvalidOperationException();
+        
+        _currentLapTrackingTimeSince = time.GetUtcNow();
+
+        State = StopwatchState.Running;
+    }
+
+    public void Stop()
+    {
+        if (State != StopwatchState.Running)
+            throw new InvalidOperationException();
+
+        _currentLapTrackedTime += CurrentLap;
+        _currentLapTrackingTimeSince = null;
+        
+        State = StopwatchState.Stopped;
+    }
+
+    public void Reset()
+    {
+        if (State != StopwatchState.Stopped)
+            throw new InvalidOperationException();
+        
+        _previousLaps.Clear();
+        _currentLapTrackingTimeSince = null;
+        _currentLapTrackedTime = TimeSpan.Zero;
+        
+        State = StopwatchState.Ready;
+    }
+
+    public void Lap()
+    {
+        if (State != StopwatchState.Running)
+            throw new InvalidOperationException();
+        
+        _previousLaps.Add(CurrentLap);
+        _currentLapTrackedTime = TimeSpan.Zero;
+        _currentLapTrackingTimeSince = time.GetUtcNow();
+    }
+}

exercises/practice/split-second-stopwatch/.meta/Generator.tpl

@@ -1,12 +1,49 @@
-using Xunit;
+{{ func to_timespan
+    if $0 == "00:00:00"
+        ret "TimeSpan.Zero"
+    end
+
+    parts = string.split $0 ":"
+    hours = parts[0] | string.to_int
+    minutes = parts[1] | string.to_int
+    seconds = parts[2] | string.to_int        
+    $"new TimeSpan({hours},{minutes},{seconds})"
+end }}
+
+using Microsoft.Extensions.Time.Testing;
 
 public class {{ testClass }}
 {
     {{- for test in tests }}
     [Fact{{ if !for.first }}(Skip = "Remove this Skip property to run this test"){{ end }}]
     public void {{ test.testMethod }}()
     {
-        Assert.Equal({{ test.expected }}, {{ testedClass }}.{{ test.testedMethod }}({{ test.input.commands }}));
+        {{- for command in test.input.commands }}
+        {{- if command.command == "new" }}
+        var timeProvider = new FakeTimeProvider();
+        var stopwatch = new {{ testedClass }}(timeProvider);
+        {{- else if command.command == "state" }}
+        Assert.Equal({{ command.expected | enum "StopwatchState" }}, stopwatch.State);
+        {{- else if command.command == "currentLap" }}
+        Assert.Equal({{ command.expected | to_timespan }}, stopwatch.CurrentLap);
+        {{- else if command.command == "total" }}
+        Assert.Equal({{ command.expected | to_timespan }}, stopwatch.Total);
+        {{- else if command.command == "previousLaps" }}
+        {{- if command.expected.empty? }}
+        Assert.Empty(stopwatch.PreviousLaps);
+        {{ else }}
+        Assert.Equal([{{- for previousLap in command.expected }}{{ previousLap | to_timespan }}{{ if !for.last }}, {{ end }}{{ end -}}], stopwatch.PreviousLaps);
+        {{ end -}}
+        {{- else if command.command == "advanceTime" }}
+        timeProvider.Advance({{ command.by | to_timespan }});
+        {{- else }}
+        {{- if command.expected && command.expected.error }}
+        Assert.Throws<InvalidOperationException>(() => stopwatch.{{ command.command | pascalize }}());
+        {{ else }}
+        stopwatch.{{ command.command | pascalize }}();
+        {{ end -}}
+        {{ end -}}
+        {{ end -}}
     }
     {{ end -}}
 }

exercises/practice/split-second-stopwatch/SplitSecondStopwatch.cs

@@ -1,59 +1,34 @@
 public enum StopwatchState
 {
     Ready,
-    Running
+    Running,
+    Stopped
 }
 
 public class SplitSecondStopwatch(TimeProvider time)
-{
-    private readonly List<TimeSpan> _splits = new();
-    private DateTimeOffset? _splitStart;
-    
-    private TimeSpan PreviousSplits => _splits.Aggregate(TimeSpan.Zero, (total, split) => total + split);
-    private TimeSpan CurrentSplit => _splitStart is {} start ? time.GetUtcNow() - start : TimeSpan.Zero;
-
-    public StopwatchState State { get; private set; } = StopwatchState.Ready;
-    public List<TimeSpan> PreviousLaps { get; } = new();
-
-    public TimeSpan CurrentLap => CurrentSplit + PreviousSplits;
-    public TimeSpan Total => CurrentLap + PreviousLaps.Aggregate(TimeSpan.Zero, (total, split) => total + split);
+{    
+    public StopwatchState State { get; }
+    public TimeSpan CurrentLap { get; }
+    public TimeSpan Total { get; }
+    public IReadOnlyCollection<TimeSpan> PreviousLaps { get; }
 
     public void Start()
     {
-        if (State != StopwatchState.Ready)
-            throw new InvalidOperationException("Can't start a stopwatch that is not stopped.");
-        
-        _splitStart = time.GetUtcNow();
-        State = StopwatchState.Running;
+        throw new NotImplementedException("You need to implement this method.");
     }
 
     public void Stop()
     {
-        if (State != StopwatchState.Running)
-            throw new InvalidOperationException("Can't stop a stopwatch that is not started.");
-
-        _splits.Add(CurrentSplit);
-        _splitStart = null;
-        State = StopwatchState.Ready;
+        throw new NotImplementedException("You need to implement this method.");
     }
-    
+
     public void Reset()
     {
-        if (State != StopwatchState.Ready)
-            throw new InvalidOperationException("Can't reset a stopwatch that is not stopped.");
-        
-        _splits.Clear();
-        _splitStart = null;
-        State = StopwatchState.Ready;
+        throw new NotImplementedException("You need to implement this method.");
     }
-    
+
     public void Lap()
     {
-        if (State != StopwatchState.Running)
-            throw new InvalidOperationException("Can't lap a stopwatch that is not started stopped.");
-        
-        PreviousLaps.Add(CurrentLap);
-        _splits.Clear();
-        _splitStart = time.GetUtcNow();
+        throw new NotImplementedException("You need to implement this method.");
     }
 }