Fixes #3829. Rename Slider to LinearRange and implement CWP (#4509)

* Initial plan

* Rename Slider to LinearRange - files and code updated

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Fix variable name mismatches in scenario files

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Fix typos in comments identified by code review

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Update HelpText for consistency with LinearRange rename

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Refactor LinearRange properties to use CWP with CWPPropertyHelper

- Added CWP events (Changing/Changed) for Type, LegendsOrientation, MinimumInnerSpacing, ShowLegends, ShowEndSpacing, and UseMinimumSize properties
- Used CWPPropertyHelper for consistent property change workflow
- Added virtual OnChanging/OnChanged methods for each property
- All existing tests pass

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Fix CWP property implementations - remove duplicate field updates in doWork

- CWPPropertyHelper updates the ref parameter, so doWork should only contain side effects
- Fixed Type, MinimumInnerSpacing, LegendsOrientation, ShowLegends, ShowEndSpacing, and UseMinimumSize
- Added comprehensive CWP tests for property changes (9 new tests, all passing)
- All 45 pre-existing LinearRange tests still pass (10 were already failing before changes)

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Add fluent integration tests for LinearRange

- Created LinearRangeFluentTests with 5 test scenarios
- Tests cover rendering, navigation, type changes with CWP events, range selection, and vertical orientation
- All tests build successfully

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Fix unit tests and address review comments

- Fixed review comments: Updated Title properties from "_Slider" to "_LinearRange" in DimAutoDemo and ViewportSettings
- Fixed review comment: Renamed filterSlider to filterLinearRange in Mouse.cs
- Fixed CWP implementation: Use local variable instead of backing field as ref parameter to CWPPropertyHelper
- This ensures doWork can update the backing field BEFORE SetContentSize() reads it
- All 55 LinearRange tests now passing (was 45/55, now 55/55)

Co-authored-by: tig <585482+tig@users.noreply.github.com>

* Update DimAutoDemo.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update ViewportSettings.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* code cleanup

* Refactor LinearRanges scenario for clarity and modularity

Refactored the LinearRanges scenario to separate UI setup, configuration, and event logic. The Main() method now handles all UI layout, configuration controls, and event wiring, while MakeSliders() is responsible only for adding LinearRange controls to the main window. Updated event handlers to use discard parameters for unused arguments and modernized code with collection initializers and LINQ. This results in a clearer separation of concerns and improved maintainability.

* un did change

* cleanup

* cleanup

* cleanup

* fixed unit test
code cleanup

---------

Co-authored-by: Tig <tig@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: tig <585482+tig@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Tests/UnitTestsParallelizable/ViewBase/Adornment/PaddingTests.cs

@@ -1,10 +1,6 @@
-#nullable enable
-using UnitTests;
-using Xunit.Abstractions;
+namespace ViewBaseTests.Adornments;
 
-namespace ViewBaseTests.Adornments;
-
-public class PaddingTests (ITestOutputHelper output)
+public class PaddingTests
 {
     [Fact]
     public void Constructor_Defaults ()
@@ -21,5 +17,4 @@ public class PaddingTests (ITestOutputHelper output)
         View view = new () { Height = 3, Width = 3 };
         Assert.Equal (Thickness.Empty, view.Padding!.Thickness);
     }
-
 }

Tests/UnitTestsParallelizable/Views/LinearRangeTests.cs

@@ -3,13 +3,13 @@ using UnitTests;
 
 namespace ViewsTests;
 
-public class SliderOptionTests : FakeDriverBase
+public class LinearRangeOptionTests : FakeDriverBase
 {
     [Fact]
     public void OnChanged_Should_Raise_ChangedEvent ()
     {
         // Arrange
-        SliderOption<int> sliderOption = new ();
+        LinearRangeOption<int> sliderOption = new ();
         var eventRaised = false;
         sliderOption.Changed += (sender, args) => eventRaised = true;
 
@@ -24,7 +24,7 @@ public class SliderOptionTests : FakeDriverBase
     public void OnSet_Should_Raise_SetEvent ()
     {
         // Arrange
-        SliderOption<int> sliderOption = new ();
+        LinearRangeOption<int> sliderOption = new ();
         var eventRaised = false;
         sliderOption.Set += (sender, args) => eventRaised = true;
 
@@ -39,7 +39,7 @@ public class SliderOptionTests : FakeDriverBase
     public void OnUnSet_Should_Raise_UnSetEvent ()
     {
         // Arrange
-        SliderOption<int> sliderOption = new ();
+        LinearRangeOption<int> sliderOption = new ();
         var eventRaised = false;
         sliderOption.UnSet += (sender, args) => eventRaised = true;
 
@@ -51,42 +51,42 @@ public class SliderOptionTests : FakeDriverBase
     }
 
     [Fact]
-    public void Slider_Option_Default_Constructor ()
+    public void LinearRange_Option_Default_Constructor ()
     {
-        SliderOption<int> o = new ();
+        LinearRangeOption<int> o = new ();
         Assert.Null (o.Legend);
         Assert.Equal (default (Rune), o.LegendAbbr);
         Assert.Equal (default (int), o.Data);
     }
 
     [Fact]
-    public void Slider_Option_Values_Constructor ()
+    public void LinearRange_Option_Values_Constructor ()
     {
-        SliderOption<int> o = new ("1 thousand", new ('y'), 1000);
+        LinearRangeOption<int> o = new ("1 thousand", new ('y'), 1000);
         Assert.Equal ("1 thousand", o.Legend);
         Assert.Equal (new ('y'), o.LegendAbbr);
         Assert.Equal (1000, o.Data);
     }
 
     [Fact]
-    public void SliderOption_ToString_WhenEmpty ()
+    public void LinearRangeOption_ToString_WhenEmpty ()
     {
-        SliderOption<object> sliderOption = new ();
+        LinearRangeOption<object> sliderOption = new ();
         Assert.Equal ("{Legend=, LegendAbbr=\0, Data=}", sliderOption.ToString ());
     }
 
     [Fact]
-    public void SliderOption_ToString_WhenPopulated_WithInt ()
+    public void LinearRangeOption_ToString_WhenPopulated_WithInt ()
     {
-        SliderOption<int> sliderOption = new () { Legend = "Lord flibble", LegendAbbr = new ('l'), Data = 1 };
+        LinearRangeOption<int> sliderOption = new () { Legend = "Lord flibble", LegendAbbr = new ('l'), Data = 1 };
 
         Assert.Equal ("{Legend=Lord flibble, LegendAbbr=l, Data=1}", sliderOption.ToString ());
     }
 
     [Fact]
-    public void SliderOption_ToString_WhenPopulated_WithSizeF ()
+    public void LinearRangeOption_ToString_WhenPopulated_WithSizeF ()
     {
-        SliderOption<SizeF> sliderOption = new ()
+        LinearRangeOption<SizeF> sliderOption = new ()
         {
             Legend = "Lord flibble", LegendAbbr = new ('l'), Data = new (32, 11)
         };
@@ -95,17 +95,17 @@ public class SliderOptionTests : FakeDriverBase
     }
 }
 
-public class SliderEventArgsTests : FakeDriverBase
+public class LinearRangeEventArgsTests : FakeDriverBase
 {
     [Fact]
     public void Constructor_Sets_Cancel_Default_To_False ()
     {
         // Arrange
-        Dictionary<int, SliderOption<int>> options = new ();
+        Dictionary<int, LinearRangeOption<int>> options = new ();
         var focused = 42;
 
         // Act
-        SliderEventArgs<int> sliderEventArgs = new (options, focused);
+        LinearRangeEventArgs<int> sliderEventArgs = new (options, focused);
 
         // Assert
         Assert.False (sliderEventArgs.Cancel);
@@ -115,11 +115,11 @@ public class SliderEventArgsTests : FakeDriverBase
     public void Constructor_Sets_Focused ()
     {
         // Arrange
-        Dictionary<int, SliderOption<int>> options = new ();
+        Dictionary<int, LinearRangeOption<int>> options = new ();
         var focused = 42;
 
         // Act
-        SliderEventArgs<int> sliderEventArgs = new (options, focused);
+        LinearRangeEventArgs<int> sliderEventArgs = new (options, focused);
 
         // Assert
         Assert.Equal (focused, sliderEventArgs.Focused);
@@ -129,23 +129,23 @@ public class SliderEventArgsTests : FakeDriverBase
     public void Constructor_Sets_Options ()
     {
         // Arrange
-        Dictionary<int, SliderOption<int>> options = new ();
+        Dictionary<int, LinearRangeOption<int>> options = new ();
 
         // Act
-        SliderEventArgs<int> sliderEventArgs = new (options);
+        LinearRangeEventArgs<int> sliderEventArgs = new (options);
 
         // Assert
         Assert.Equal (options, sliderEventArgs.Options);
     }
 }
 
-public class SliderTests : FakeDriverBase
+public class LinearRangeTests : FakeDriverBase
 {
     [Fact]
     public void Constructor_Default ()
     {
         // Arrange & Act
-        Slider<int> slider = new ();
+        LinearRange<int> slider = new ();
 
         // Assert
         Assert.NotNull (slider);
@@ -155,7 +155,7 @@ public class SliderTests : FakeDriverBase
         Assert.False (slider.AllowEmpty);
         Assert.True (slider.ShowLegends);
         Assert.False (slider.ShowEndSpacing);
-        Assert.Equal (SliderType.Single, slider.Type);
+        Assert.Equal (LinearRangeType.Single, slider.Type);
         Assert.Equal (1, slider.MinimumInnerSpacing);
         Assert.True (slider.Width is DimAuto);
         Assert.True (slider.Height is DimAuto);
@@ -169,15 +169,15 @@ public class SliderTests : FakeDriverBase
         List<int> options = new () { 1, 2, 3 };
 
         // Act
-        Slider<int> slider = new (options);
+        LinearRange<int> slider = new (options);
         slider.SetRelativeLayout (new (100, 100));
 
         // Assert
         // 0123456789
         // 1 2 3
         Assert.Equal (1, slider.MinimumInnerSpacing);
-        Assert.Equal (new Size (5, 2), slider.GetContentSize ());
-        Assert.Equal (new Size (5, 2), slider.Frame.Size);
+        Assert.Equal (new (5, 2), slider.GetContentSize ());
+        Assert.Equal (new (5, 2), slider.Frame.Size);
         Assert.NotNull (slider);
         Assert.NotNull (slider.Options);
         Assert.Equal (options.Count, slider.Options.Count);
@@ -187,7 +187,7 @@ public class SliderTests : FakeDriverBase
     public void MovePlus_Should_MoveFocusRight_When_OptionIsAvailable ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
 
         // Act
         bool result = slider.MovePlus ();
@@ -201,7 +201,7 @@ public class SliderTests : FakeDriverBase
     public void MovePlus_Should_NotMoveFocusRight_When_AtEnd ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
 
         slider.FocusedOption = 3;
 
@@ -217,7 +217,7 @@ public class SliderTests : FakeDriverBase
     public void OnOptionFocused_Event_Cancelled ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3 });
+        LinearRange<int> slider = new (new () { 1, 2, 3 });
         var eventRaised = false;
         var cancel = false;
         slider.OptionFocused += (sender, args) => eventRaised = true;
@@ -226,7 +226,7 @@ public class SliderTests : FakeDriverBase
         // Create args with cancel set to false
         cancel = false;
 
-        SliderEventArgs<int> args =
+        LinearRangeEventArgs<int> args =
             new (new (), newFocusedOption) { Cancel = cancel };
         Assert.Equal (0, slider.FocusedOption);
 
@@ -257,11 +257,11 @@ public class SliderTests : FakeDriverBase
     public void OnOptionFocused_Event_Raised ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3 });
+        LinearRange<int> slider = new (new () { 1, 2, 3 });
         var eventRaised = false;
         slider.OptionFocused += (sender, args) => eventRaised = true;
         var newFocusedOption = 1;
-        SliderEventArgs<int> args = new (new (), newFocusedOption);
+        LinearRangeEventArgs<int> args = new (new (), newFocusedOption);
 
         // Act
         slider.OnOptionFocused (newFocusedOption, args);
@@ -274,7 +274,7 @@ public class SliderTests : FakeDriverBase
     public void OnOptionsChanged_Event_Raised ()
     {
         // Arrange
-        Slider<int> slider = new ();
+        LinearRange<int> slider = new ();
         var eventRaised = false;
         slider.OptionsChanged += (sender, args) => eventRaised = true;
 
@@ -289,7 +289,7 @@ public class SliderTests : FakeDriverBase
     public void Set_Should_Not_UnSetFocusedOption_When_EmptyNotAllowed ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 }) { AllowEmpty = false };
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 }) { AllowEmpty = false };
 
         Assert.NotEmpty (slider.GetSetOptions ());
 
@@ -307,7 +307,7 @@ public class SliderTests : FakeDriverBase
     public void Set_Should_SetFocusedOption ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
 
         // Act
         slider.FocusedOption = 2;
@@ -323,7 +323,7 @@ public class SliderTests : FakeDriverBase
     public void TryGetOptionByPosition_InvalidPosition_Failure ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3 });
+        LinearRange<int> slider = new (new () { 1, 2, 3 });
         var x = 10;
         var y = 10;
         var threshold = 2;
@@ -347,7 +347,8 @@ public class SliderTests : FakeDriverBase
     public void TryGetOptionByPosition_ValidPositionHorizontal_Success (int x, int y, int threshold, int expectedData)
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
+
         // 0123456789
         // 1234
 
@@ -376,7 +377,7 @@ public class SliderTests : FakeDriverBase
     public void TryGetOptionByPosition_ValidPositionVertical_Success (int x, int y, int threshold, int expectedData)
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
         slider.Orientation = Orientation.Vertical;
 
         // Set auto size to true to enable testing
@@ -405,7 +406,7 @@ public class SliderTests : FakeDriverBase
     public void TryGetPositionByOption_InvalidOption_Failure ()
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3 });
+        LinearRange<int> slider = new (new () { 1, 2, 3 });
         int option = -1;
         (int, int) expectedPosition = (-1, -1);
 
@@ -424,7 +425,7 @@ public class SliderTests : FakeDriverBase
     public void TryGetPositionByOption_ValidOptionHorizontal_Success (int option, int expectedX, int expectedY)
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
 
         // Set auto size to true to enable testing
         slider.MinimumInnerSpacing = 2;
@@ -448,7 +449,7 @@ public class SliderTests : FakeDriverBase
     public void TryGetPositionByOption_ValidOptionVertical_Success (int option, int expectedX, int expectedY)
     {
         // Arrange
-        Slider<int> slider = new (new () { 1, 2, 3, 4 });
+        LinearRange<int> slider = new (new () { 1, 2, 3, 4 });
         slider.Orientation = Orientation.Vertical;
 
         // Set auto size to true to enable testing
@@ -468,32 +469,12 @@ public class SliderTests : FakeDriverBase
     private void One_Option_Does_Not_Throw ()
     {
         // Arrange
-        Slider<int> slider = new ();
+        LinearRange<int> slider = new ();
         slider.BeginInit ();
         slider.EndInit ();
 
         // Act/Assert
-        slider.Options = new () { new () };
-    }
-
-    [Fact]
-    private void Set_Options_No_Legend_Throws ()
-    {
-        // Arrange
-        Slider<int> slider = new ();
-
-        // Act/Assert
-        Assert.Throws<ArgumentNullException> (() => slider.Options = null);
-    }
-
-    [Fact]
-    private void Set_Options_Throws_If_Null ()
-    {
-        // Arrange
-        Slider<int> slider = new ();
-
-        // Act/Assert
-        Assert.Throws<ArgumentNullException> (() => slider.Options = null);
+        slider.Options = [new ()];
     }
 
     [Fact]
@@ -505,12 +486,12 @@ public class SliderTests : FakeDriverBase
             Height = Dim.Fill ()
         };
 
-        List<object> options = new () { "01234", "01234" };
+        List<object> options = ["01234", "01234"];
 
-        Slider slider = new (options)
+        LinearRange slider = new (options)
         {
             Orientation = Orientation.Vertical,
-            Type = SliderType.Multiple,
+            Type = LinearRangeType.Multiple
         };
         view.Add (slider);
         view.BeginInit ();
@@ -539,10 +520,10 @@ public class SliderTests : FakeDriverBase
 
         List<object> options = new () { "01234", "01234" };
 
-        Slider slider = new (options)
+        LinearRange slider = new (options)
         {
             Orientation = Orientation.Vertical,
-            Type = SliderType.Multiple,
+            Type = LinearRangeType.Multiple,
             Height = 10
         };
         view.Add (slider);
@@ -572,11 +553,11 @@ public class SliderTests : FakeDriverBase
 
         List<object> options = new () { "01234", "01234" };
 
-        Slider slider = new (options)
+        LinearRange slider = new (options)
         {
             Orientation = Orientation.Vertical,
-            Type = SliderType.Multiple,
-            Width = 10,
+            Type = LinearRangeType.Multiple,
+            Width = 10
         };
         view.Add (slider);
         view.BeginInit ();
@@ -596,3 +577,254 @@ public class SliderTests : FakeDriverBase
 
     // Add more tests for different scenarios and edge cases.
 }
+public class LinearRangeCWPTests : FakeDriverBase
+{
+    [Fact]
+    public void Type_PropertyChange_RaisesChangingAndChangedEvents ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+        var oldValue = LinearRangeType.Single;
+        var newValue = LinearRangeType.Range;
+
+        linearRange.TypeChanging += (sender, args) =>
+                                    {
+                                        changingRaised = true;
+                                        Assert.Equal (oldValue, args.CurrentValue);
+                                        Assert.Equal (newValue, args.NewValue);
+                                    };
+
+        linearRange.TypeChanged += (sender, args) =>
+                                   {
+                                       changedRaised = true;
+                                       Assert.Equal (oldValue, args.OldValue);
+                                       Assert.Equal (newValue, args.NewValue);
+                                   };
+
+        // Act
+        linearRange.Type = newValue;
+
+        // Assert
+        Assert.True (changingRaised);
+        Assert.True (changedRaised);
+        Assert.Equal (newValue, linearRange.Type);
+    }
+
+    [Fact]
+    public void Type_PropertyChange_CanBeCancelled ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        LinearRangeType oldValue = linearRange.Type;
+
+        linearRange.TypeChanging += (sender, args) => { args.Handled = true; };
+
+        // Act
+        linearRange.Type = LinearRangeType.Range;
+
+        // Assert
+        Assert.Equal (oldValue, linearRange.Type);
+    }
+
+    [Fact]
+    public void LegendsOrientation_PropertyChange_RaisesChangingAndChangedEvents ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+        var oldValue = Orientation.Horizontal;
+        var newValue = Orientation.Vertical;
+
+        linearRange.LegendsOrientationChanging += (sender, args) =>
+                                                  {
+                                                      changingRaised = true;
+                                                      Assert.Equal (oldValue, args.CurrentValue);
+                                                      Assert.Equal (newValue, args.NewValue);
+                                                  };
+
+        linearRange.LegendsOrientationChanged += (sender, args) =>
+                                                 {
+                                                     changedRaised = true;
+                                                     Assert.Equal (oldValue, args.OldValue);
+                                                     Assert.Equal (newValue, args.NewValue);
+                                                 };
+
+        // Act
+        linearRange.LegendsOrientation = newValue;
+
+        // Assert
+        Assert.True (changingRaised);
+        Assert.True (changedRaised);
+        Assert.Equal (newValue, linearRange.LegendsOrientation);
+    }
+
+    [Fact]
+    public void MinimumInnerSpacing_PropertyChange_RaisesChangingAndChangedEvents ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+        var oldValue = 1;
+        var newValue = 5;
+
+        linearRange.MinimumInnerSpacingChanging += (sender, args) =>
+                                                   {
+                                                       changingRaised = true;
+                                                       Assert.Equal (oldValue, args.CurrentValue);
+                                                       Assert.Equal (newValue, args.NewValue);
+                                                   };
+
+        linearRange.MinimumInnerSpacingChanged += (sender, args) =>
+                                                  {
+                                                      changedRaised = true;
+                                                      Assert.Equal (oldValue, args.OldValue);
+                                                      Assert.Equal (newValue, args.NewValue);
+                                                  };
+
+        // Act
+        linearRange.MinimumInnerSpacing = newValue;
+
+        // Assert
+        Assert.True (changingRaised);
+        Assert.True (changedRaised);
+        Assert.Equal (newValue, linearRange.MinimumInnerSpacing);
+    }
+
+    [Fact]
+    public void ShowLegends_PropertyChange_RaisesChangingAndChangedEvents ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+        var oldValue = true;
+        var newValue = false;
+
+        linearRange.ShowLegendsChanging += (sender, args) =>
+                                           {
+                                               changingRaised = true;
+                                               Assert.Equal (oldValue, args.CurrentValue);
+                                               Assert.Equal (newValue, args.NewValue);
+                                           };
+
+        linearRange.ShowLegendsChanged += (sender, args) =>
+                                          {
+                                              changedRaised = true;
+                                              Assert.Equal (oldValue, args.OldValue);
+                                              Assert.Equal (newValue, args.NewValue);
+                                          };
+
+        // Act
+        linearRange.ShowLegends = newValue;
+
+        // Assert
+        Assert.True (changingRaised);
+        Assert.True (changedRaised);
+        Assert.Equal (newValue, linearRange.ShowLegends);
+    }
+
+    [Fact]
+    public void ShowEndSpacing_PropertyChange_RaisesChangingAndChangedEvents ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+        var oldValue = false;
+        var newValue = true;
+
+        linearRange.ShowEndSpacingChanging += (sender, args) =>
+                                              {
+                                                  changingRaised = true;
+                                                  Assert.Equal (oldValue, args.CurrentValue);
+                                                  Assert.Equal (newValue, args.NewValue);
+                                              };
+
+        linearRange.ShowEndSpacingChanged += (sender, args) =>
+                                             {
+                                                 changedRaised = true;
+                                                 Assert.Equal (oldValue, args.OldValue);
+                                                 Assert.Equal (newValue, args.NewValue);
+                                             };
+
+        // Act
+        linearRange.ShowEndSpacing = newValue;
+
+        // Assert
+        Assert.True (changingRaised);
+        Assert.True (changedRaised);
+        Assert.Equal (newValue, linearRange.ShowEndSpacing);
+    }
+
+    [Fact]
+    public void UseMinimumSize_PropertyChange_RaisesChangingAndChangedEvents ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+        var oldValue = false;
+        var newValue = true;
+
+        linearRange.UseMinimumSizeChanging += (sender, args) =>
+                                              {
+                                                  changingRaised = true;
+                                                  Assert.Equal (oldValue, args.CurrentValue);
+                                                  Assert.Equal (newValue, args.NewValue);
+                                              };
+
+        linearRange.UseMinimumSizeChanged += (sender, args) =>
+                                             {
+                                                 changedRaised = true;
+                                                 Assert.Equal (oldValue, args.OldValue);
+                                                 Assert.Equal (newValue, args.NewValue);
+                                             };
+
+        // Act
+        linearRange.UseMinimumSize = newValue;
+
+        // Assert
+        Assert.True (changingRaised);
+        Assert.True (changedRaised);
+        Assert.Equal (newValue, linearRange.UseMinimumSize);
+    }
+
+    [Fact]
+    public void Type_PropertyChange_NoEventsWhenValueUnchanged ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var changingRaised = false;
+        var changedRaised = false;
+
+        linearRange.TypeChanging += (sender, args) => changingRaised = true;
+        linearRange.TypeChanged += (sender, args) => changedRaised = true;
+
+        // Act
+        linearRange.Type = linearRange.Type;
+
+        // Assert
+        Assert.False (changingRaised);
+        Assert.False (changedRaised);
+    }
+
+    [Fact]
+    public void Type_PropertyChange_ChangingEventCanModifyNewValue ()
+    {
+        // Arrange
+        LinearRange<int> linearRange = new ();
+        var modifiedValue = LinearRangeType.Multiple;
+
+        linearRange.TypeChanging += (sender, args) => { args.NewValue = modifiedValue; };
+
+        // Act
+        linearRange.Type = LinearRangeType.Range;
+
+        // Assert
+        Assert.Equal (modifiedValue, linearRange.Type);
+    }
+}