fix variable names

Author: rose-a

Src/FluentAssertions.Reactive/FluentTestObserver.cs

@@ -17,9 +17,9 @@ namespace FluentAssertions.Reactive
     /// <typeparam name="TPayload"></typeparam>
     public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
     {
-        private readonly IDisposable _subscription;
-        private readonly IScheduler _observeScheduler;
-        private readonly RollingReplaySubject<Recorded<Notification<TPayload>>> _rollingReplaySubject = new RollingReplaySubject<Recorded<Notification<TPayload>>>();
+        private readonly IDisposable subscription;
+        private readonly IScheduler observeScheduler;
+        private readonly RollingReplaySubject<Recorded<Notification<TPayload>>> rollingReplaySubject = new RollingReplaySubject<Recorded<Notification<TPayload>>>();
 
         /// <summary>
         /// The observable which is observed by this instance
@@ -29,13 +29,13 @@ public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
         /// <summary>
         /// The stream of recorded <see cref="Notification{T}"/>s
         /// </summary>
-        public IObservable<Recorded<Notification<TPayload>>> RecordedNotificationStream => _rollingReplaySubject.AsObservable();
+        public IObservable<Recorded<Notification<TPayload>>> RecordedNotificationStream => rollingReplaySubject.AsObservable();
 
         /// <summary>
         /// The recorded <see cref="Notification{T}"/>s
         /// </summary>
         public IEnumerable<Recorded<Notification<TPayload>>> RecordedNotifications =>
-            _rollingReplaySubject.GetSnapshot();
+            rollingReplaySubject.GetSnapshot();
 
         /// <summary>
         /// The recorded messages
@@ -66,8 +66,8 @@ public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
         public FluentTestObserver(IObservable<TPayload> subject)
         {
             Subject = subject;
-            _observeScheduler = new EventLoopScheduler();
-            _subscription = new CompositeDisposable(); subject.ObserveOn(_observeScheduler).Subscribe(this);
+            observeScheduler = new EventLoopScheduler();
+            subscription = new CompositeDisposable(); subject.ObserveOn(observeScheduler).Subscribe(this);
         }
 
         /// <summary>
@@ -77,8 +77,8 @@ public FluentTestObserver(IObservable<TPayload> subject)
         public FluentTestObserver(IObservable<TPayload> subject, IScheduler scheduler)
         {
             Subject = subject;
-            _observeScheduler = scheduler;
-            _subscription = subject.ObserveOn(scheduler).Subscribe(this);
+            observeScheduler = scheduler;
+            subscription = subject.ObserveOn(scheduler).Subscribe(this);
         }
 
         /// <summary>
@@ -88,35 +88,35 @@ public FluentTestObserver(IObservable<TPayload> subject, IScheduler scheduler)
         public FluentTestObserver(IObservable<TPayload> subject, TestScheduler testScheduler)
         {
             Subject = subject;
-            _observeScheduler = testScheduler;
-            _subscription = subject.ObserveOn(Scheduler.CurrentThread).Subscribe(this);
+            observeScheduler = testScheduler;
+            subscription = subject.ObserveOn(Scheduler.CurrentThread).Subscribe(this);
         }
 
         /// <summary>
         /// Clears the recorded notifications and messages as well as the recorded notifications stream buffer
         /// </summary>
-        public void Clear() => _rollingReplaySubject.Clear();
+        public void Clear() => rollingReplaySubject.Clear();
 
         /// <inheritdoc />
         public void OnNext(TPayload value)
         {
-            _rollingReplaySubject.OnNext(
-                new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
+            rollingReplaySubject.OnNext(
+                new Recorded<Notification<TPayload>>(observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
         }
 
         /// <inheritdoc />
         public void OnError(Exception exception) =>
-            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnError<TPayload>(exception)));
+            rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(observeScheduler.Now.UtcTicks, Notification.CreateOnError<TPayload>(exception)));
 
         /// <inheritdoc />
         public void OnCompleted() =>
-            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnCompleted<TPayload>()));
+            rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(observeScheduler.Now.UtcTicks, Notification.CreateOnCompleted<TPayload>()));
 
         /// <inheritdoc />
         public void Dispose()
         {
-            _subscription?.Dispose();
-            _rollingReplaySubject?.Dispose();
+            subscription?.Dispose();
+            rollingReplaySubject?.Dispose();
         }
 
         /// <summary>

Src/FluentAssertions.Reactive/RollingReplaySubject.cs

@@ -11,39 +11,39 @@ namespace FluentAssertions.Reactive
     /// <typeparam name="T"></typeparam>
     public class RollingReplaySubject<T> : ISubject<T>, IDisposable
     {
-        private readonly ReplaySubject<IObservable<T>> _subjects;
-        private readonly IObservable<T> _concatenatedSubjects;
-        private ISubject<T> _currentSubject;
+        private readonly ReplaySubject<IObservable<T>> subjects;
+        private readonly IObservable<T> concatenatedSubjects;
+        private ISubject<T> currentSubject;
 
         public RollingReplaySubject()
         {
-            _subjects = new ReplaySubject<IObservable<T>>(1);
-            _concatenatedSubjects = _subjects.Concat();
-            _currentSubject = new ReplaySubject<T>();
-            _subjects.OnNext(_currentSubject);
+            subjects = new ReplaySubject<IObservable<T>>(1);
+            concatenatedSubjects = subjects.Concat();
+            currentSubject = new ReplaySubject<T>();
+            subjects.OnNext(currentSubject);
         }
 
         public void Clear()
         {
-            _currentSubject.OnCompleted();
-            _currentSubject = new ReplaySubject<T>();
-            _subjects.OnNext(_currentSubject);
+            currentSubject.OnCompleted();
+            currentSubject = new ReplaySubject<T>();
+            subjects.OnNext(currentSubject);
         }
 
-        public void OnNext(T value) => _currentSubject.OnNext(value);
+        public void OnNext(T value) => currentSubject.OnNext(value);
 
-        public void OnError(Exception error) => _currentSubject.OnError(error);
+        public void OnError(Exception error) => currentSubject.OnError(error);
 
         public void OnCompleted()
         {
-            _currentSubject.OnCompleted();
-            _subjects.OnCompleted();
+            currentSubject.OnCompleted();
+            subjects.OnCompleted();
             // a quick way to make the current ReplaySubject unreachable
             // except to in-flight observers, and not hold up collection
-            _currentSubject = new Subject<T>();
+            currentSubject = new Subject<T>();
         }
 
-        public IDisposable Subscribe(IObserver<T> observer) => _concatenatedSubjects.Subscribe(observer);
+        public IDisposable Subscribe(IObserver<T> observer) => concatenatedSubjects.Subscribe(observer);
 
         public IEnumerable<T> GetSnapshot()
         {
@@ -58,7 +58,7 @@ public IEnumerable<T> GetSnapshot()
         public void Dispose()
         {
             OnCompleted();
-            _subjects?.Dispose();
+            subjects?.Dispose();
         }
     }
 }