diff --git a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownTests.cs b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownTests.cs
index 44e42c0b148..bb421adbd34 100644
--- a/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownTests.cs
+++ b/src/System.Windows.Forms/tests/UnitTests/System/Windows/Forms/DomainUpDownTests.cs
@@ -7,273 +7,278 @@
 
 namespace System.Windows.Forms.Tests;
 
-public class DomainUpDownTests
+public class DomainUpDownTests : IDisposable
 {
+    private readonly DomainUpDown _control;
+    private readonly SubDomainUpDown _sub;
+
+    public DomainUpDownTests()
+    {
+        _control = new();
+        _sub = new();
+    }
+
+    public void Dispose()
+    {
+       _control.Items.Clear();
+       _control.Dispose();
+       _sub.Items.Clear();
+       _sub.Dispose();
+    }
+
     [WinFormsFact]
     public void DomainUpDown_Ctor_Default()
     {
-        using SubDomainUpDown control = new();
-        Assert.Null(control.ActiveControl);
-        Assert.False(control.AllowDrop);
-        Assert.Equal(AnchorStyles.Top | AnchorStyles.Left, control.Anchor);
-        Assert.False(control.AutoScroll);
-        Assert.Equal(SizeF.Empty, control.AutoScaleDimensions);
-        Assert.Equal(new SizeF(1, 1), control.AutoScaleFactor);
-        Assert.Equal(Size.Empty, control.AutoScrollMargin);
-        Assert.Equal(AutoScaleMode.Inherit, control.AutoScaleMode);
-        Assert.Equal(Size.Empty, control.AutoScrollMinSize);
-        Assert.Equal(Point.Empty, control.AutoScrollPosition);
-        Assert.False(control.AutoSize);
-        Assert.Equal(SystemColors.Window, control.BackColor);
-        Assert.Null(control.BackgroundImage);
-        Assert.Equal(ImageLayout.Tile, control.BackgroundImageLayout);
-        Assert.NotNull(control.BindingContext);
-        Assert.Same(control.BindingContext, control.BindingContext);
-        Assert.Equal(BorderStyle.Fixed3D, control.BorderStyle);
-        Assert.Equal(control.PreferredHeight, control.Bottom);
-        Assert.Equal(new Rectangle(0, 0, 120, control.PreferredHeight), control.Bounds);
-        Assert.False(control.CanEnableIme);
-        Assert.False(control.CanFocus);
-        Assert.True(control.CanRaiseEvents);
-        Assert.True(control.CausesValidation);
-        Assert.False(control.ChangingText);
+        _sub.ActiveControl.Should().BeNull();
+        _sub.AllowDrop.Should().BeFalse();
+        _sub.Anchor.Should().Be(AnchorStyles.Top | AnchorStyles.Left);
+        _sub.AutoScroll.Should().BeFalse();
+        _sub.AutoScaleDimensions.Should().Be(SizeF.Empty);
+        _sub.AutoScaleFactor.Should().Be(new SizeF(1, 1));
+        _sub.AutoScrollMargin.Should().Be(Size.Empty);
+        _sub.AutoScaleMode.Should().Be(AutoScaleMode.Inherit);
+        _sub.AutoScrollMinSize.Should().Be(Size.Empty);
+        _sub.AutoScrollPosition.Should().Be(Point.Empty);
+        _sub.AutoSize.Should().BeFalse();
+        _sub.BackColor.Should().Be(SystemColors.Window);
+        _sub.BackgroundImage.Should().BeNull();
+        _sub.BackgroundImageLayout.Should().Be(ImageLayout.Tile);
+        _sub.BindingContext.Should().NotBeNull();
+        _sub.BorderStyle.Should().Be(BorderStyle.Fixed3D);
+        _sub.Bottom.Should().Be(_sub.PreferredHeight);
+        _sub.Bounds.Should().Be(new Rectangle(0, 0, 120, _sub.PreferredHeight));
+        _sub.CanEnableIme.Should().BeFalse();
+        _sub.CanFocus.Should().BeFalse();
+        _sub.CanRaiseEvents.Should().BeTrue();
+        _sub.CausesValidation.Should().BeTrue();
+        _sub.ChangingText.Should().BeFalse();
         if (Application.UseVisualStyles)
         {
-            Assert.Equal(new Rectangle(0, 0, 120, Control.DefaultFont.Height + 7), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 120, Control.DefaultFont.Height + 7), control.DisplayRectangle);
-            Assert.Equal(new Size(120, Control.DefaultFont.Height + 7), control.ClientSize);
-            Assert.Equal(new Size(16, control.PreferredHeight), control.PreferredSize);
+            _sub.ClientRectangle.Should().Be(new Rectangle(0, 0, 120, Control.DefaultFont.Height + 7));
+            _sub.DisplayRectangle.Should().Be(new Rectangle(0, 0, 120, Control.DefaultFont.Height + 7));
+            _sub.ClientSize.Should().Be(new Size(120, Control.DefaultFont.Height + 7));
+            _sub.PreferredSize.Should().Be(new Size(16, _sub.PreferredHeight));
         }
         else
         {
-            Assert.Equal(new Rectangle(0, 0, 116, Control.DefaultFont.Height + 3), control.ClientRectangle);
-            Assert.Equal(new Rectangle(0, 0, 116, Control.DefaultFont.Height + 3), control.DisplayRectangle);
-            Assert.Equal(new Size(116, Control.DefaultFont.Height + 3), control.ClientSize);
-            Assert.Equal(new Size(20, control.PreferredHeight), control.PreferredSize);
+            _sub.ClientRectangle.Should().Be(new Rectangle(0, 0, 116, Control.DefaultFont.Height + 3));
+            _sub.DisplayRectangle.Should().Be(new Rectangle(0, 0, 116, Control.DefaultFont.Height + 3));
+            _sub.ClientSize.Should().Be(new Size(116, Control.DefaultFont.Height + 3));
+            _sub.PreferredSize.Should().Be(new Size(20, _sub.PreferredHeight));
         }
 
-        Assert.Null(control.Container);
-        Assert.False(control.ContainsFocus);
-        Assert.Null(control.ContextMenuStrip);
-        Assert.NotEmpty(control.Controls);
-        Assert.Same(control.Controls, control.Controls);
-        Assert.False(control.Created);
-        Assert.Equal(SizeF.Empty, control.CurrentAutoScaleDimensions);
-        Assert.Equal(Cursors.Default, control.Cursor);
-        Assert.Equal(Cursors.Default, control.DefaultCursor);
-        Assert.Equal(ImeMode.Inherit, control.DefaultImeMode);
-        Assert.Equal(new Padding(3), control.DefaultMargin);
-        Assert.Equal(Size.Empty, control.DefaultMaximumSize);
-        Assert.Equal(Size.Empty, control.DefaultMinimumSize);
-        Assert.Equal(Padding.Empty, control.DefaultPadding);
-        Assert.Equal(new Size(120, control.PreferredHeight), control.DefaultSize);
-        Assert.False(control.DesignMode);
-        Assert.Equal(DockStyle.None, control.Dock);
-        Assert.NotNull(control.DockPadding);
-        Assert.Same(control.DockPadding, control.DockPadding);
-        Assert.Equal(0, control.DockPadding.Top);
-        Assert.Equal(0, control.DockPadding.Bottom);
-        Assert.Equal(0, control.DockPadding.Left);
-        Assert.Equal(0, control.DockPadding.Right);
-        Assert.False(control.DoubleBuffered);
-        Assert.True(control.Enabled);
-        Assert.NotNull(control.Events);
-        Assert.Same(control.Events, control.Events);
-        Assert.False(control.Focused);
-        Assert.Equal(Control.DefaultFont, control.Font);
-        Assert.Equal(control.Font.Height, control.FontHeight);
-        Assert.Equal(SystemColors.WindowText, control.ForeColor);
-        Assert.True(control.HasChildren);
-        Assert.Equal(control.PreferredHeight, control.Height);
-        Assert.NotNull(control.HorizontalScroll);
-        Assert.Same(control.HorizontalScroll, control.HorizontalScroll);
-        Assert.False(control.HScroll);
-        Assert.Equal(ImeMode.NoControl, control.ImeMode);
-        Assert.Equal(ImeMode.NoControl, control.ImeModeBase);
-        Assert.True(control.InterceptArrowKeys);
-        Assert.False(control.InvokeRequired);
-        Assert.False(control.IsAccessible);
-        Assert.False(control.IsMirrored);
-        Assert.Empty(control.Items);
-        Assert.Same(control.Items, control.Items);
-        Assert.NotNull(control.LayoutEngine);
-        Assert.Same(control.LayoutEngine, control.LayoutEngine);
-        Assert.Equal(0, control.Left);
-        Assert.Equal(Point.Empty, control.Location);
-        Assert.Equal(new Padding(3), control.Margin);
-        Assert.Equal(Size.Empty, control.MaximumSize);
-        Assert.Equal(Size.Empty, control.MinimumSize);
-        Assert.Equal(Padding.Empty, control.Padding);
-        Assert.Null(control.Parent);
-        Assert.Equal(Control.DefaultFont.Height + 7, control.PreferredHeight);
-        Assert.Equal("Microsoft\u00AE .NET", control.ProductName);
-        Assert.False(control.ReadOnly);
-        Assert.False(control.RecreatingHandle);
-        Assert.Null(control.Region);
-        Assert.True(control.ResizeRedraw);
-        Assert.Equal(120, control.Right);
-        Assert.Equal(RightToLeft.No, control.RightToLeft);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.True(control.ShowFocusCues);
-        Assert.True(control.ShowKeyboardCues);
-        Assert.Null(control.Site);
-        Assert.Equal(new Size(120, control.PreferredHeight), control.Size);
-        Assert.Equal(0, control.TabIndex);
-        Assert.True(control.TabStop);
-        Assert.Empty(control.Text);
-        Assert.Equal(HorizontalAlignment.Left, control.TextAlign);
-        Assert.Equal(0, control.Top);
-        Assert.Null(control.TopLevelControl);
-        Assert.Equal(LeftRightAlignment.Right, control.UpDownAlign);
-        Assert.False(control.UserEdit);
-        Assert.False(control.UseWaitCursor);
-        Assert.True(control.Visible);
-        Assert.NotNull(control.VerticalScroll);
-        Assert.Same(control.VerticalScroll, control.VerticalScroll);
-        Assert.False(control.VScroll);
-        Assert.Equal(120, control.Width);
-        Assert.False(control.Wrap);
-
-        Assert.False(control.IsHandleCreated);
+        _sub.Container.Should().BeNull();
+        _sub.ContainsFocus.Should().BeFalse();
+        _sub.ContextMenuStrip.Should().BeNull();
+        _sub.Controls.Should().NotBeNull();
+        _sub.Controls.Should().BeSameAs(_sub.Controls);
+        _sub.Created.Should().BeFalse();
+        _sub.CurrentAutoScaleDimensions.Should().Be(SizeF.Empty);
+        _sub.Cursor.Should().Be(Cursors.Default);
+        _sub.DefaultCursor.Should().Be(Cursors.Default);
+        _sub.DefaultImeMode.Should().Be(ImeMode.Inherit);
+        _sub.DefaultMargin.Should().Be(new Padding(3));
+        _sub.DefaultMaximumSize.Should().Be(Size.Empty);
+        _sub.DefaultMinimumSize.Should().Be(Size.Empty);
+        _sub.DefaultPadding.Should().Be(Padding.Empty);
+        _sub.DefaultSize.Should().Be(new Size(120, _sub.PreferredHeight));
+        _sub.DesignMode.Should().BeFalse();
+        _sub.Dock.Should().Be(DockStyle.None);
+        _sub.DockPadding.Should().NotBeNull();
+        _sub.DockPadding.Should().BeSameAs(_sub.DockPadding);
+        _sub.DockPadding.Top.Should().Be(0);
+        _sub.DockPadding.Bottom.Should().Be(0);
+        _sub.DockPadding.Left.Should().Be(0);
+        _sub.DockPadding.Right.Should().Be(0);
+        _sub.DoubleBuffered.Should().BeFalse();
+        _sub.Enabled.Should().BeTrue();
+        _sub.Events.Should().NotBeNull();
+        _sub.Events.Should().BeSameAs(_sub.Events);
+        _sub.Focused.Should().BeFalse();
+        _sub.Font.Should().Be(Control.DefaultFont);
+        _sub.FontHeight.Should().Be(_sub.Font.Height);
+        _sub.ForeColor.Should().Be(SystemColors.WindowText);
+        _sub.HasChildren.Should().BeTrue();
+        _sub.Height.Should().Be(_sub.PreferredHeight);
+        _sub.HorizontalScroll.Should().NotBeNull();
+        _sub.HorizontalScroll.Should().BeSameAs(_sub.HorizontalScroll);
+        _sub.HScroll.Should().BeFalse();
+        _sub.ImeMode.Should().Be(ImeMode.NoControl);
+        _sub.ImeModeBase.Should().Be(ImeMode.NoControl);
+        _sub.InterceptArrowKeys.Should().BeTrue();
+        _sub.InvokeRequired.Should().BeFalse();
+        _sub.IsAccessible.Should().BeFalse();
+        _sub.IsMirrored.Should().BeFalse();
+        _sub.Items.Count.Should().Be(0);
+        _sub.Items.Should().BeSameAs(_sub.Items);
+        _sub.LayoutEngine.Should().NotBeNull();
+        _sub.LayoutEngine.Should().BeSameAs(_sub.LayoutEngine);
+        _sub.Left.Should().Be(0);
+        _sub.Location.Should().Be(Point.Empty);
+        _sub.Margin.Should().Be(new Padding(3));
+        _sub.MaximumSize.Should().Be(Size.Empty);
+        _sub.MinimumSize.Should().Be(Size.Empty);
+        _sub.Padding.Should().Be(Padding.Empty);
+        _sub.Parent.Should().BeNull();
+        _sub.PreferredHeight.Should().Be(Control.DefaultFont.Height + 7);
+        _sub.ProductName.Should().Be("Microsoft\u00AE .NET");
+        _sub.ReadOnly.Should().BeFalse();
+        _sub.RecreatingHandle.Should().BeFalse();
+        _sub.Region.Should().BeNull();
+        _sub.ResizeRedraw.Should().BeTrue();
+        _sub.Right.Should().Be(120);
+        _sub.RightToLeft.Should().Be(RightToLeft.No);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.ShowFocusCues.Should().BeTrue();
+        _sub.ShowKeyboardCues.Should().BeTrue();
+        _sub.Site.Should().BeNull();
+        _sub.Size.Should().Be(new Size(120, _sub.PreferredHeight));
+        _sub.TabIndex.Should().Be(0);
+        _sub.TabStop.Should().BeTrue();
+        _sub.Text.Should().BeEmpty();
+        _sub.TextAlign.Should().Be(HorizontalAlignment.Left);
+        _sub.Top.Should().Be(0);
+        _sub.TopLevelControl.Should().BeNull();
+        _sub.UpDownAlign.Should().Be(LeftRightAlignment.Right);
+        _sub.UserEdit.Should().BeFalse();
+        _sub.UseWaitCursor.Should().BeFalse();
+        _sub.Visible.Should().BeTrue();
+        _sub.VerticalScroll.Should().NotBeNull();
+        _sub.VerticalScroll.Should().BeSameAs(_sub.VerticalScroll);
+        _sub.VScroll.Should().BeFalse();
+        _sub.Width.Should().Be(120);
+        _sub.Wrap.Should().BeFalse();
+
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsFact]
     public void DomainUpDown_CreateParams_GetDefault_ReturnsExpected()
     {
-        using SubDomainUpDown control = new();
-        CreateParams createParams = control.CreateParams;
-        Assert.Null(createParams.Caption);
-        Assert.Null(createParams.ClassName);
+        CreateParams createParams = _sub.CreateParams;
+        createParams.Caption.Should().BeNull();
+        createParams.ClassName.Should().BeNull();
 
-        Assert.Equal(WNDCLASS_STYLES.CS_DBLCLKS, (WNDCLASS_STYLES)createParams.ClassStyle);
-        Assert.Equal(WINDOW_STYLE.WS_MAXIMIZEBOX | WINDOW_STYLE.WS_CLIPCHILDREN | WINDOW_STYLE.WS_CLIPSIBLINGS
-            | WINDOW_STYLE.WS_VISIBLE | WINDOW_STYLE.WS_CHILD, (WINDOW_STYLE)createParams.Style);
+        ((WNDCLASS_STYLES)createParams.ClassStyle).Should().Be(WNDCLASS_STYLES.CS_DBLCLKS);
+        ((WINDOW_STYLE)createParams.Style).Should().Be(WINDOW_STYLE.WS_MAXIMIZEBOX | WINDOW_STYLE.WS_CLIPCHILDREN | WINDOW_STYLE.WS_CLIPSIBLINGS
+            | WINDOW_STYLE.WS_VISIBLE | WINDOW_STYLE.WS_CHILD);
 
         if (Application.UseVisualStyles)
         {
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_CONTROLPARENT, (WINDOW_EX_STYLE)createParams.ExStyle);
+            ((WINDOW_EX_STYLE)createParams.ExStyle).Should().Be(WINDOW_EX_STYLE.WS_EX_CONTROLPARENT);
         }
         else
         {
-            Assert.Equal(WINDOW_EX_STYLE.WS_EX_CLIENTEDGE | WINDOW_EX_STYLE.WS_EX_CONTROLPARENT, (WINDOW_EX_STYLE)createParams.ExStyle);
+            ((WINDOW_EX_STYLE)createParams.ExStyle).Should().Be(WINDOW_EX_STYLE.WS_EX_CLIENTEDGE | WINDOW_EX_STYLE.WS_EX_CONTROLPARENT);
         }
 
-        Assert.Equal(control.PreferredHeight, createParams.Height);
-        Assert.Equal(IntPtr.Zero, createParams.Parent);
-        Assert.Null(createParams.Param);
-        Assert.Equal(120, createParams.Width);
-        Assert.Equal(0, createParams.X);
-        Assert.Equal(0, createParams.Y);
-        Assert.Same(createParams, control.CreateParams);
-        Assert.False(control.IsHandleCreated);
+        createParams.Height.Should().Be(_sub.PreferredHeight);
+        createParams.Parent.Should().Be(IntPtr.Zero);
+        createParams.Param.Should().BeNull();
+        createParams.Width.Should().Be(120);
+        createParams.X.Should().Be(0);
+        createParams.Y.Should().Be(0);
+        createParams.Should().BeSameAs(_sub.CreateParams);
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
     [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
     public void DomainUpDown_Padding_Set_GetReturnsExpected(Padding value, Padding expected)
     {
-        using DomainUpDown control = new()
-        {
-            Padding = value
-        };
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
+        _control.Padding = value;
 
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.False(control.IsHandleCreated);
+        _control.Padding.Should().Be(expected);
+        _control.IsHandleCreated.Should().BeFalse();
+
+        _control.Padding = value;
+        _control.Padding.Should().Be(expected);
+        _control.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
     [CommonMemberData(typeof(CommonTestHelperEx), nameof(CommonTestHelperEx.GetPaddingNormalizedTheoryData))]
     public void DomainUpDown_Padding_SetWithHandle_GetReturnsExpected(Padding value, Padding expected)
     {
-        using DomainUpDown control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
+        _control.Handle.Should().NotBe(IntPtr.Zero);
         int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
+        _control.Invalidated += (sender, e) => invalidatedCallCount++;
         int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
+        _control.StyleChanged += (sender, e) => styleChangedCallCount++;
         int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
-
-        // Set same.
-        control.Padding = value;
-        Assert.Equal(expected, control.Padding);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _control.HandleCreated += (sender, e) => createdCallCount++;
+
+        _control.Padding = value;
+        _control.Padding.Should().Be(expected);
+        _control.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
+
+        _control.Padding = value;
+        _control.Padding.Should().Be(expected);
+        _control.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
     }
 
     [WinFormsFact]
     public void DomainUpDown_Padding_SetWithHandler_CallsPaddingChanged()
     {
-        using DomainUpDown control = new();
         int callCount = 0;
         EventHandler handler = (sender, e) =>
         {
-            Assert.Equal(control, sender);
-            Assert.Same(EventArgs.Empty, e);
+            sender.Should().Be(_control);
+            e.Should().Be(EventArgs.Empty);
             callCount++;
         };
-        control.PaddingChanged += handler;
+        _control.PaddingChanged += handler;
 
         // Set different.
         Padding padding1 = new(1);
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
+        _control.Padding = padding1;
+        _control.Padding.Should().Be(padding1);
+        callCount.Should().Be(1);
 
         // Set same.
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(1, callCount);
+        _control.Padding = padding1;
+        _control.Padding.Should().Be(padding1);
+        callCount.Should().Be(1);
 
         // Set different.
         Padding padding2 = new(2);
-        control.Padding = padding2;
-        Assert.Equal(padding2, control.Padding);
-        Assert.Equal(2, callCount);
+        _control.Padding = padding2;
+        _control.Padding.Should().Be(padding2);
+        callCount.Should().Be(2);
 
         // Remove handler.
-        control.PaddingChanged -= handler;
-        control.Padding = padding1;
-        Assert.Equal(padding1, control.Padding);
-        Assert.Equal(2, callCount);
+        _control.PaddingChanged -= handler;
+        _control.Padding = padding1;
+        _control.Padding.Should().Be(padding1);
+        callCount.Should().Be(2);
     }
 
     [WinFormsFact]
     public void DomainUpDown_SelectedIndex_SetEmpty_Nop()
     {
-        using SubDomainUpDown control = new()
-        {
-            SelectedIndex = -1
-        };
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
-
-        // Set same.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedIndex = -1;
+
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
+
+        _sub.SelectedIndex = -1;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -282,35 +287,34 @@ public void DomainUpDown_SelectedIndex_SetEmpty_Nop()
     [InlineData(-1, null, "", false)]
     public void DomainUpDown_SelectedIndex_SetNotEmpty_GetReturnsExpected(int value, object expected, string expectedText, bool expectedUserEdit)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.Items.Add("Item1");
+        _sub.Items.Add("Item2");
+
+        _sub.SelectedIndex = value;
+        _sub.SelectedIndex.Should().Be(value);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedIndex = value;
+        _sub.SelectedIndex.Should().Be(value);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set none.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedIndex = -1;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -319,96 +323,92 @@ public void DomainUpDown_SelectedIndex_SetNotEmpty_GetReturnsExpected(int value,
     [InlineData(-1, null, "", false)]
     public void DomainUpDown_SelectedIndex_SetUserEdit_GetReturnsExpected(int value, object expected, string expectedText, bool expectedUserEdit)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = true
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(!expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.UserEdit=true;
+        _sub.Items.Add("Item1");
+        _sub.Items.Add("Item2");
+
+        _sub.SelectedIndex = value;
+        _sub.SelectedIndex.Should().Be(value);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(!expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.SelectedIndex = value;
-        Assert.Equal(value, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(!expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedIndex = value;
+        _sub.SelectedIndex.Should().Be(value);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(!expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set none.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.True(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedIndex = -1;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeTrue();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
-    [WinFormsFact]
+   [WinFormsFact]
     public void DomainUpDown_SelectedIndex_SetWithHandler_CallsSelectedItemChanged()
     {
-        using DomainUpDown control = new();
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
+        _control.Items.Add("Item1");
+        _control.Items.Add("Item2");
 
         int textChangedCallCount = 0;
         int callCount = 0;
         EventHandler textChangedHandler = (sender, e) =>
         {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
+            sender.Should().Be(_control);
+            e.Should().Be(EventArgs.Empty);
             textChangedCallCount++;
         };
         EventHandler handler = (sender, e) =>
         {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(textChangedCallCount - 1, callCount);
+            sender.Should().Be(_control);
+            e.Should().Be(EventArgs.Empty);
+            (textChangedCallCount - 1).Should().Be(callCount);
             callCount++;
         };
-        control.TextChanged += textChangedHandler;
-        control.SelectedItemChanged += handler;
+        _control.TextChanged += textChangedHandler;
+        _control.SelectedItemChanged += handler;
 
         // Set different.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
+        _control.SelectedIndex = 0;
+        _control.SelectedIndex.Should().Be(0);
+        textChangedCallCount.Should().Be(1);
+        callCount.Should().Be(1);
 
         // Set same.
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
+        _control.SelectedIndex = 0;
+        _control.SelectedIndex.Should().Be(0);
+        textChangedCallCount.Should().Be(1);
+        callCount.Should().Be(1);
 
         // Set different.
-        control.SelectedIndex = 1;
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
+        _control.SelectedIndex = 1;
+        _control.SelectedIndex.Should().Be(1);
+        textChangedCallCount.Should().Be(2);
+        callCount.Should().Be(2);
 
         // Set none.
-        control.SelectedIndex = -1;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
+        _control.SelectedIndex = -1;
+        _control.SelectedIndex.Should().Be(-1);
+        textChangedCallCount.Should().Be(2);
+        callCount.Should().Be(2);
 
         // Remove handler.
-        control.TextChanged -= textChangedHandler;
-        control.SelectedItemChanged -= handler;
-        control.SelectedIndex = 0;
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
+        _control.TextChanged -= textChangedHandler;
+        _control.SelectedItemChanged -= handler;
+        _control.SelectedIndex = 0;
+        _control.SelectedIndex.Should().Be(0);
+        textChangedCallCount.Should().Be(2);
+        callCount.Should().Be(2);
     }
 
     [WinFormsTheory]
@@ -417,8 +417,7 @@ public void DomainUpDown_SelectedIndex_SetWithHandler_CallsSelectedItemChanged()
     [InlineData(1)]
     public void DomainUpDown_SelectedIndex_SetInvalidValueEmpty_ThrowsArgumentOutOfRangeException(int value)
     {
-        using DomainUpDown control = new();
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = value);
+        _control.Invoking(c => c.SelectedIndex = value).Should().Throw<ArgumentOutOfRangeException>().And.ParamName.Should().Be("value");
     }
 
     [WinFormsTheory]
@@ -427,9 +426,8 @@ public void DomainUpDown_SelectedIndex_SetInvalidValueEmpty_ThrowsArgumentOutOfR
     [InlineData(2)]
     public void DomainUpDown_SelectedIndex_SetInvalidValueNotEmpty_ThrowsArgumentOutOfRangeException(int value)
     {
-        using DomainUpDown control = new();
-        control.Items.Add("Item");
-        Assert.Throws<ArgumentOutOfRangeException>("value", () => control.SelectedIndex = value);
+        _control.Items.Add("Item");
+        _control.Invoking(c => c.SelectedIndex = value).Should().Throw<ArgumentOutOfRangeException>().And.ParamName.Should().Be("value");
     }
 
     [WinFormsTheory]
@@ -437,25 +435,22 @@ public void DomainUpDown_SelectedIndex_SetInvalidValueNotEmpty_ThrowsArgumentOut
     [InlineData("NoSuchItem")]
     public void DomainUpDown_SelectedItem_SetEmpty_Nop(object value)
     {
-        using SubDomainUpDown control = new()
-        {
-            SelectedItem = value
-        };
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = value;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.SelectedItem = value;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = value;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -465,44 +460,43 @@ public void DomainUpDown_SelectedItem_SetEmpty_Nop(object value)
     [InlineData(null, -1, null, "", false)]
     public void DomainUpDown_SelectedItem_SetNotEmpty_GetReturnsExpected(object value, int expectedSelectedIndex, object expected, string expectedText, bool expectedUserEdit)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-
-        control.SelectedItem = value;
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.Items.Add("Item1");
+        _sub.Items.Add("Item2");
+
+        _sub.SelectedItem = value;
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.SelectedItem = value;
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = value;
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set no such item.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = "NoSuchItem";
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set none.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = null;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -512,105 +506,101 @@ public void DomainUpDown_SelectedItem_SetNotEmpty_GetReturnsExpected(object valu
     [InlineData(null, -1, null, "", false)]
     public void DomainUpDown_SelectedItem_SetUserEdit_GetReturnsExpected(object value, int expectedSelectedIndex, object expected, string expectedText, bool expectedUserEdit)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = true
-        };
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-
-        control.SelectedItem = value;
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(!expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.UserEdit = true;
+        _sub.Items.Add("Item1");
+        _sub.Items.Add("Item2");
+
+        _sub.SelectedItem = value;
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(!expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.SelectedItem = value;
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(!expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = value;
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(!expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set no such item.
-        control.SelectedItem = "NoSuchItem";
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(expected, control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.Equal(!expectedUserEdit, control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = "NoSuchItem";
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.SelectedItem.Should().Be(expected);
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().Be(!expectedUserEdit);
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set none.
-        control.SelectedItem = null;
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Null(control.SelectedItem);
-        Assert.Equal(expectedText, control.Text);
-        Assert.True(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.SelectedItem = null;
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.SelectedItem.Should().BeNull();
+        _sub.Text.Should().Be(expectedText);
+        _sub.UserEdit.Should().BeTrue();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsFact]
     public void DomainUpDown_SelectedItem_SetWithHandler_CallsSelectedItemChanged()
     {
-        using DomainUpDown control = new();
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
+        _control.Items.Add("Item1");
+        _control.Items.Add("Item2");
 
         int textChangedCallCount = 0;
         int callCount = 0;
         EventHandler textChangedHandler = (sender, e) =>
         {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
+            sender.Should().Be(_control);
+            e.Should().Be(EventArgs.Empty);
             textChangedCallCount++;
         };
         EventHandler handler = (sender, e) =>
         {
-            Assert.Same(control, sender);
-            Assert.Same(EventArgs.Empty, e);
-            Assert.Equal(textChangedCallCount - 1, callCount);
+            sender.Should().Be(_control);
+            e.Should().Be(EventArgs.Empty);
+            (textChangedCallCount - 1).Should().Be(callCount);
             callCount++;
         };
-        control.TextChanged += textChangedHandler;
-        control.SelectedItemChanged += handler;
+        _control.TextChanged += textChangedHandler;
+        _control.SelectedItemChanged += handler;
 
         // Set different.
-        control.SelectedItem = "Item1";
-        Assert.Equal("Item1", control.SelectedItem);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
+        _control.SelectedItem = "Item1";
+        _control.SelectedItem.Should().Be("Item1");
+        textChangedCallCount.Should().Be(1);
+        callCount.Should().Be(1);
 
         // Set same.
-        control.SelectedItem = "Item1";
-        Assert.Equal("Item1", control.SelectedItem);
-        Assert.Equal(1, textChangedCallCount);
-        Assert.Equal(1, callCount);
+        _control.SelectedItem = "Item1";
+        _control.SelectedItem.Should().Be("Item1");
+        textChangedCallCount.Should().Be(1);
+        callCount.Should().Be(1);
 
         // Set different.
-        control.SelectedItem = "Item2";
-        Assert.Equal("Item2", control.SelectedItem);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
+        _control.SelectedItem = "Item2";
+        _control.SelectedItem.Should().Be("Item2");
+        textChangedCallCount.Should().Be(2);
+        callCount.Should().Be(2);
 
         // Set none.
-        control.SelectedItem = null;
-        Assert.Null(control.SelectedItem);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
+        _control.SelectedItem = null;
+        _control.SelectedItem.Should().BeNull();
+        textChangedCallCount.Should().Be(2);
+        callCount.Should().Be(2);
 
         // Remove handler.
-        control.TextChanged -= textChangedHandler;
-        control.SelectedItemChanged -= handler;
-        control.SelectedItem = "Item1";
-        Assert.Equal("Item1", control.SelectedItem);
-        Assert.Equal(2, textChangedCallCount);
-        Assert.Equal(2, callCount);
+        _control.TextChanged -= textChangedHandler;
+        _control.SelectedItemChanged -= handler;
+        _control.SelectedItem = "Item1";
+        _control.SelectedItem.Should().Be("Item1");
+        textChangedCallCount.Should().Be(2);
+        callCount.Should().Be(2);
     }
 
     public static IEnumerable<object[]> Sorted_Set_TestData()
@@ -626,32 +616,30 @@ public static IEnumerable<object[]> Sorted_Set_TestData()
     [MemberData(nameof(Sorted_Set_TestData))]
     public void DomainUpDown_Sorted_Set_GetReturnsExpected(bool userEdit, bool value)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Sorted = value
-        };
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.UserEdit = userEdit;
+        _sub.Sorted = value;
+
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Count.Should().Be(0);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Count.Should().Be(0);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.Sorted = !value;
+        _sub.Sorted.Should().Be(!value);
+        _sub.Items.Count.Should().Be(0);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     public static IEnumerable<object[]> Sorted_WithItems_TestData()
@@ -667,35 +655,34 @@ public static IEnumerable<object[]> Sorted_WithItems_TestData()
     [MemberData(nameof(Sorted_WithItems_TestData))]
     public void DomainUpDown_Sorted_SetWithItems_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("c");
-        control.Items.Add("B");
-        control.Items.Add("a");
-        control.Items.Add("a");
-        control.Items.Add("d");
-        control.UserEdit = userEdit;
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
+        _sub.Items.Add("c");
+        _sub.Items.Add("B");
+        _sub.Items.Add("a");
+        _sub.Items.Add("a");
+        _sub.Items.Add("d");
+        _sub.UserEdit = userEdit;
+
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Equal(new string[] { "a", "a", "B", "c", "d" }, control.Items.Cast<string>());
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.Sorted = !value;
+        _sub.Sorted.Should().Be(!value);
+        _sub.Items.Cast<string>().Should().Equal(new string[] { "a", "a", "B", "c", "d" });
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     public static IEnumerable<object[]> Sorted_WithItemsWithSelection_TestData()
@@ -710,274 +697,262 @@ public static IEnumerable<object[]> Sorted_WithItemsWithSelection_TestData()
     [MemberData(nameof(Sorted_WithItemsWithSelection_TestData))]
     public void DomainUpDown_Sorted_SetWithItemsWithSelection_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems, int expectedSelectedIndex)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("c");
-        control.Items.Add("B");
-        control.Items.Add("a");
-        control.Items.Add("a");
-        control.Items.Add("d");
-        control.SelectedItem = "B";
-        control.UserEdit = userEdit;
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.False(control.IsHandleCreated);
+        _sub.Items.Add("c");
+        _sub.Items.Add("B");
+        _sub.Items.Add("a");
+        _sub.Items.Add("a");
+        _sub.Items.Add("d");
+        _sub.SelectedItem = "B";
+        _sub.UserEdit = userEdit;
+
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Equal(new string[] { "a", "a", "B", "c", "d" }, control.Items.Cast<string>());
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.False(control.IsHandleCreated);
+        _sub.Sorted = !value;
+        _sub.Sorted.Should().Be(!value);
+        _sub.Items.Cast<string>().Should().Equal(new string[] { "a", "a", "B", "c", "d" });
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
     [MemberData(nameof(Sorted_Set_TestData))]
     public void DomainUpDown_Sorted_SetWithHandle_GetReturnsExpected(bool userEdit, bool value)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit
-        };
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
+        _sub.UserEdit = userEdit;
+        _sub.Handle.Should().NotBe(IntPtr.Zero);
         int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
+        _sub.Invalidated += (sender, e) => invalidatedCallCount++;
         int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
+        _sub.StyleChanged += (sender, e) => styleChangedCallCount++;
         int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.HandleCreated += (sender, e) => createdCallCount++;
+
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Count.Should().Be(0);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Count.Should().Be(0);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Empty(control.Items);
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.Sorted = !value;
+        _sub.Sorted.Should().Be(!value);
+        _sub.Items.Count.Should().Be(0);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
     }
 
     [WinFormsTheory]
     [MemberData(nameof(Sorted_WithItems_TestData))]
     public void DomainUpDown_Sorted_SetWithItemsWithHandle_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("c");
-        control.Items.Add("B");
-        control.Items.Add("a");
-        control.Items.Add("a");
-        control.Items.Add("d");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
+        _sub.Items.Add("c");
+        _sub.Items.Add("B");
+        _sub.Items.Add("a");
+        _sub.Items.Add("a");
+        _sub.Items.Add("d");
+        _sub.Handle.Should().NotBe(IntPtr.Zero);
         int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
+        _sub.Invalidated += (sender, e) => invalidatedCallCount++;
         int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
+        _sub.StyleChanged += (sender, e) => styleChangedCallCount++;
         int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.UserEdit = userEdit;
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.HandleCreated += (sender, e) => createdCallCount++;
+        _sub.UserEdit = userEdit;
+
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Equal(new string[] { "a", "a", "B", "c", "d" }, control.Items.Cast<string>());
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.Sorted = !value;
+        _sub.Sorted.Should().Be(!value);
+        _sub.Items.Cast<string>().Should().Equal(new string[] { "a", "a", "B", "c", "d" });
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
     }
 
     [WinFormsTheory]
     [MemberData(nameof(Sorted_WithItemsWithSelection_TestData))]
     public void DomainUpDown_Sorted_SetWithItemsWithSelectionWithHandle_GetReturnsExpected(bool userEdit, bool value, string[] expectedItems, int expectedSelectedIndex)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("c");
-        control.Items.Add("B");
-        control.Items.Add("a");
-        control.Items.Add("a");
-        control.Items.Add("d");
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
+        _sub.Items.Add("c");
+        _sub.Items.Add("B");
+        _sub.Items.Add("a");
+        _sub.Items.Add("a");
+        _sub.Items.Add("d");
+        _sub.Handle.Should().NotBe(IntPtr.Zero);
         int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
+        _sub.Invalidated += (sender, e) => invalidatedCallCount++;
         int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
+        _sub.StyleChanged += (sender, e) => styleChangedCallCount++;
         int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
-        control.SelectedItem = "B";
-        control.UserEdit = userEdit;
-
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.HandleCreated += (sender, e) => createdCallCount++;
+        _sub.SelectedItem = "B";
+        _sub.UserEdit = userEdit;
+
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set same.
-        control.Sorted = value;
-        Assert.Equal(value, control.Sorted);
-        Assert.Equal(expectedItems, control.Items.Cast<string>());
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.Sorted = value;
+        _sub.Sorted.Should().Be(value);
+        _sub.Items.Cast<string>().Should().Equal(expectedItems);
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set different.
-        control.Sorted = !value;
-        Assert.Equal(!value, control.Sorted);
-        Assert.Equal(new string[] { "a", "a", "B", "c", "d" }, control.Items.Cast<string>());
-        Assert.Equal(expectedSelectedIndex, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _sub.Sorted = !value;
+        _sub.Sorted.Should().Be(!value);
+        _sub.Items.Cast<string>().Should().Equal(new string[] { "a", "a", "B", "c", "d" });
+        _sub.SelectedIndex.Should().Be(expectedSelectedIndex);
+        _sub.UserEdit.Should().Be(userEdit);
+        _sub.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
     }
 
     [WinFormsTheory]
     [BoolData]
     public void DomainUpDown_Wrap_Set_GetReturnsExpected(bool value)
     {
-        using DomainUpDown control = new()
-        {
-            Wrap = value
-        };
-        Assert.Equal(value, control.Wrap);
-        Assert.False(control.IsHandleCreated);
+        _control.Wrap = value;
+
+        _control.Wrap.Should().Be(value);
+        _control.IsHandleCreated.Should().BeFalse();
 
         // Set same.
-        control.Wrap = value;
-        Assert.Equal(value, control.Wrap);
-        Assert.False(control.IsHandleCreated);
+        _control.Wrap = value;
+        _control.Wrap.Should().Be(value);
+        _control.IsHandleCreated.Should().BeFalse();
 
         // Set different.
-        control.Wrap = !value;
-        Assert.Equal(!value, control.Wrap);
-        Assert.False(control.IsHandleCreated);
+        _control.Wrap = !value;
+        _control.Wrap.Should().Be(!value);
+        _control.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
     [BoolData]
     public void DomainUpDown_Wrap_SetWithHandle_GetReturnsExpected(bool value)
     {
-        using DomainUpDown control = new();
-        Assert.NotEqual(IntPtr.Zero, control.Handle);
+        _control.Handle.Should().NotBe(IntPtr.Zero);
         int invalidatedCallCount = 0;
-        control.Invalidated += (sender, e) => invalidatedCallCount++;
+        _control.Invalidated += (sender, e) => invalidatedCallCount++;
         int styleChangedCallCount = 0;
-        control.StyleChanged += (sender, e) => styleChangedCallCount++;
+        _control.StyleChanged += (sender, e) => styleChangedCallCount++;
         int createdCallCount = 0;
-        control.HandleCreated += (sender, e) => createdCallCount++;
+        _control.HandleCreated += (sender, e) => createdCallCount++;
 
-        control.Wrap = value;
-        Assert.Equal(value, control.Wrap);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _control.Wrap = value;
+        _control.Wrap.Should().Be(value);
+        _control.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set same.
-        control.Wrap = value;
-        Assert.Equal(value, control.Wrap);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _control.Wrap = value;
+        _control.Wrap.Should().Be(value);
+        _control.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
 
         // Set different.
-        control.Wrap = !value;
-        Assert.Equal(!value, control.Wrap);
-        Assert.True(control.IsHandleCreated);
-        Assert.Equal(0, invalidatedCallCount);
-        Assert.Equal(0, styleChangedCallCount);
-        Assert.Equal(0, createdCallCount);
+        _control.Wrap = !value;
+        _control.Wrap.Should().Be(!value);
+        _control.IsHandleCreated.Should().BeTrue();
+        invalidatedCallCount.Should().Be(0);
+        styleChangedCallCount.Should().Be(0);
+        createdCallCount.Should().Be(0);
     }
 
     [WinFormsFact]
     public void DomainUpDown_CreateAccessibilityInstance_Invoke_ReturnsExpected()
     {
-        using SubDomainUpDown control = new();
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.SpinButton, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
+        UpDownBase.UpDownBaseAccessibleObject instance = _sub.CreateAccessibilityInstance() as UpDownBase.UpDownBaseAccessibleObject;
+        instance.Should().NotBeNull().And.BeOfType<UpDownBase.UpDownBaseAccessibleObject>();
+        instance.Owner.Should().Be(_sub);
+        instance.Role.Should().Be(AccessibleRole.SpinButton);
+        _sub.CreateAccessibilityInstance().Should().NotBeSameAs(instance);
+        _sub.AccessibilityObject.Should().NotBeSameAs(instance);
     }
 
     [WinFormsFact]
     public void DomainUpDown_CreateAccessibilityInstance_InvokeWithCustomRole_ReturnsExpected()
     {
-        using SubDomainUpDown control = new()
-        {
-            AccessibleRole = AccessibleRole.HelpBalloon
-        };
-        Control.ControlAccessibleObject instance = Assert.IsAssignableFrom<Control.ControlAccessibleObject>(control.CreateAccessibilityInstance());
-        Assert.NotNull(instance);
-        Assert.Same(control, instance.Owner);
-        Assert.Equal(AccessibleRole.HelpBalloon, instance.Role);
-        Assert.NotSame(control.CreateAccessibilityInstance(), instance);
-        Assert.NotSame(control.AccessibilityObject, instance);
+        _sub.AccessibleRole = AccessibleRole.HelpBalloon;
+        var instance = _sub.CreateAccessibilityInstance() as UpDownBase.UpDownBaseAccessibleObject;
+    
+        instance.Should().NotBeNull().And.BeOfType<UpDownBase.UpDownBaseAccessibleObject>();
+        instance.Owner.Should().Be(_sub);
+        instance.Role.Should().Be(AccessibleRole.HelpBalloon);
+        _sub.CreateAccessibilityInstance().Should().NotBeSameAs(instance);
+        _sub.AccessibilityObject.Should().NotBeSameAs(instance);
     }
 
     public static IEnumerable<object[]> DownButton_TestData()
@@ -995,41 +970,36 @@ public static IEnumerable<object[]> DownButton_TestData()
     [MemberData(nameof(DownButton_TestData))]
     public void DomainUpDown_DownButton_InvokeWithoutItems_Nop(bool userEdit, bool wrap)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
+        _sub.UserEdit = userEdit;
+        _sub.Wrap = wrap;
 
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
 
         // Call again.
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
     }
 
     [WinFormsTheory]
     [MemberData(nameof(DownButton_TestData))]
     public void DomainUpDown_DownButton_InvokeEmpty_Nop(bool userEdit, bool wrap)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        Assert.Empty(control.Items);
+        _sub.UserEdit = userEdit;
+        _sub.Wrap = wrap;
+
+        _sub.Items.Count.Should().Be(0);
 
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
 
         // Call again.
-        control.DownButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
     }
 
     public static IEnumerable<object[]> DownButton_WithItems_TestData()
@@ -1044,40 +1014,36 @@ public static IEnumerable<object[]> DownButton_WithItems_TestData()
     [MemberData(nameof(DownButton_WithItems_TestData))]
     public void DomainUpDown_DownButton_InvokeWithItems_Nop(bool userEdit, bool wrap, int expectedWrapSelectedIndex)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        control.Items.Add("a");
-        control.Items.Add("b");
-        control.Items.Add("c");
+        _sub.UserEdit = userEdit;
+        _sub.Wrap = wrap;
+        _sub.Items.Add("a");
+        _sub.Items.Add("b");
+        _sub.Items.Add("c");
 
-        control.DownButton();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(0);
+        _sub.UserEdit.Should().BeFalse();
 
         // Call again.
-        control.DownButton();
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(1);
+        _sub.UserEdit.Should().BeFalse();
 
         // Call again.
-        control.DownButton();
-        Assert.Equal(2, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(2);
+        _sub.UserEdit.Should().BeFalse();
 
         // Call again.
-        control.DownButton();
-        Assert.Equal(expectedWrapSelectedIndex, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.DownButton();
+        _sub.SelectedIndex.Should().Be(expectedWrapSelectedIndex);
+        _sub.UserEdit.Should().BeFalse();
     }
 
     [WinFormsFact]
     public void DomainUpDown_GetAutoSizeMode_Invoke_ReturnsExpected()
     {
-        using SubDomainUpDown control = new();
-        Assert.Equal(AutoSizeMode.GrowOnly, control.GetAutoSizeMode());
+        _sub.GetAutoSizeMode().Should().Be(AutoSizeMode.GrowOnly);
     }
 
     [WinFormsTheory]
@@ -1091,8 +1057,7 @@ public void DomainUpDown_GetAutoSizeMode_Invoke_ReturnsExpected()
     [InlineData((-1), false)]
     public void DomainUpDown_GetScrollState_Invoke_ReturnsExpected(int bit, bool expected)
     {
-        using SubDomainUpDown control = new();
-        Assert.Equal(expected, control.GetScrollState(bit));
+        _sub.GetScrollState(bit).Should().Be(expected);
     }
 
     [WinFormsTheory]
@@ -1118,18 +1083,16 @@ public void DomainUpDown_GetScrollState_Invoke_ReturnsExpected(int bit, bool exp
     [InlineData((ControlStyles)(-1), false)]
     public void DomainUpDown_GetStyle_Invoke_ReturnsExpected(ControlStyles flag, bool expected)
     {
-        using SubDomainUpDown control = new();
-        Assert.Equal(expected, control.GetStyle(flag));
+        _sub.GetStyle(flag).Should().Be(expected);
 
         // Call again to test caching.
-        Assert.Equal(expected, control.GetStyle(flag));
+        _sub.GetStyle(flag).Should().Be(expected);
     }
 
     [WinFormsFact]
     public void DomainUpDown_GetTopLevel_Invoke_ReturnsExpected()
     {
-        using SubDomainUpDown control = new();
-        Assert.False(control.GetTopLevel());
+        _sub.GetTopLevel().Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -1148,21 +1111,20 @@ public void DomainUpDown_GetTopLevel_Invoke_ReturnsExpected()
     [InlineData("", 0, -1)]
     public void DomainUpDown_MatchIndex(string text, int start, int expected)
     {
-        using DomainUpDown control = new();
-        control.Items.Add("foo1");
-        control.Items.Add("foo2");
-        control.Items.Add("foo3");
-        control.Items.Add("Cowman");
-        control.Items.Add("foo4");
-        Assert.Equal(expected, control.MatchIndex(text, false, start));
+        _control.Items.Add("foo1");
+        _control.Items.Add("foo2");
+        _control.Items.Add("foo3");
+        _control.Items.Add("Cowman");
+        _control.Items.Add("foo4");
+        _control.MatchIndex(text, false, start).Should().Be(expected);
     }
 
     [WinFormsFact]
     public void DomainUpDown_MatchIndex_NullText_ThrowsNullReferenceException()
     {
-        using DomainUpDown control = new();
-        control.Items.Add("item1");
-        Assert.Throws<NullReferenceException>(() => control.MatchIndex(null, false, 0));
+        _control.Items.Add("item1");
+        Action act = () => _control.MatchIndex(null, false, 0);
+        act.Should().Throw<NullReferenceException>();
     }
 
     public static IEnumerable<object[]> OnChanged_TestData()
@@ -1175,48 +1137,46 @@ public static IEnumerable<object[]> OnChanged_TestData()
     [MemberData(nameof(OnChanged_TestData))]
     public void DomainUpDown_OnChanged_Invoke_CallsSelectedItemChanged(object source, EventArgs eventArgs)
     {
-        using SubDomainUpDown control = new();
         int callCount = 0;
         EventHandler handler = (sender, e) =>
         {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
+            sender.Should().Be(_sub);
+            e.Should().Be(eventArgs);
             callCount++;
         };
 
         // Call with handler.
-        control.SelectedItemChanged += handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
+        _sub.SelectedItemChanged += handler;
+        _sub.OnSelectedItemChanged(source, eventArgs);
+        callCount.Should().Be(1);
 
         // Remove handler.
-        control.SelectedItemChanged -= handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
+        _sub.SelectedItemChanged -= handler;
+        _sub.OnSelectedItemChanged(source, eventArgs);
+        callCount.Should().Be(1);
     }
 
     [WinFormsTheory]
     [MemberData(nameof(OnChanged_TestData))]
     public void DomainUpDown_OnSelectedItemChanged_Invoke_CallsSelectedItemChanged(object source, EventArgs eventArgs)
     {
-        using SubDomainUpDown control = new();
         int callCount = 0;
         EventHandler handler = (sender, e) =>
         {
-            Assert.Same(control, sender);
-            Assert.Same(eventArgs, e);
+            sender.Should().Be(_sub);
+            e.Should().Be(eventArgs);
             callCount++;
         };
 
         // Call with handler.
-        control.SelectedItemChanged += handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
+        _sub.SelectedItemChanged += handler;
+        _sub.OnSelectedItemChanged(source, eventArgs);
+        callCount.Should().Be(1);
 
         // Remove handler.
-        control.SelectedItemChanged -= handler;
-        control.OnSelectedItemChanged(source, eventArgs);
-        Assert.Equal(1, callCount);
+        _sub.SelectedItemChanged -= handler;
+        _sub.OnSelectedItemChanged(source, eventArgs);
+        callCount.Should().Be(1);
     }
 
     public static IEnumerable<object[]> UpButton_TestData()
@@ -1234,41 +1194,36 @@ public static IEnumerable<object[]> UpButton_TestData()
     [MemberData(nameof(UpButton_TestData))]
     public void DomainUpDown_UpButton_InvokeWithoutItems_Nop(bool userEdit, bool wrap)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
+        _sub.UserEdit = userEdit;
+        _sub.Wrap = wrap;
 
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
 
         // Call again.
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
     }
 
     [WinFormsTheory]
     [MemberData(nameof(UpButton_TestData))]
     public void DomainUpDown_UpButton_InvokeEmpty_Nop(bool userEdit, bool wrap)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        Assert.Empty(control.Items);
+        _sub.UserEdit = userEdit;
+        _sub.Wrap = wrap;
+
+        _sub.Items.Count.Should().Be(0);
 
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
 
         // Call again.
-        control.UpButton();
-        Assert.Equal(-1, control.SelectedIndex);
-        Assert.Equal(userEdit, control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(-1);
+        _sub.UserEdit.Should().Be(userEdit);
     }
 
     public static IEnumerable<object[]> UpButton_WithItems_TestData()
@@ -1283,34 +1238,31 @@ public static IEnumerable<object[]> UpButton_WithItems_TestData()
     [MemberData(nameof(UpButton_WithItems_TestData))]
     public void DomainUpDown_UpButton_InvokeWithItems_Nop(bool userEdit, bool wrap, int expectedWrapSelectedIndex1, int expectedWrapSelectedIndex2)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            Wrap = wrap
-        };
-        control.Items.Add("a");
-        control.Items.Add("b");
-        control.Items.Add("c");
-        control.SelectedIndex = 2;
+        _sub.UserEdit = userEdit;
+        _sub.Wrap = wrap;
+        _sub.Items.Add("a");
+        _sub.Items.Add("b");
+        _sub.Items.Add("c");
+        _sub.SelectedIndex = 2;
 
-        control.UpButton();
-        Assert.Equal(1, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(1);
+        _sub.UserEdit.Should().BeFalse();
 
         // Call again.
-        control.UpButton();
-        Assert.Equal(0, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(0);
+        _sub.UserEdit.Should().BeFalse();
 
         // Call again.
-        control.UpButton();
-        Assert.Equal(expectedWrapSelectedIndex1, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(expectedWrapSelectedIndex1);
+        _sub.UserEdit.Should().BeFalse();
 
         // Call again.
-        control.UpButton();
-        Assert.Equal(expectedWrapSelectedIndex2, control.SelectedIndex);
-        Assert.False(control.UserEdit);
+        _sub.UpButton();
+        _sub.SelectedIndex.Should().Be(expectedWrapSelectedIndex2);
+        _sub.UserEdit.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -1320,23 +1272,21 @@ public void DomainUpDown_UpButton_InvokeWithItems_Nop(bool userEdit, bool wrap,
     [InlineData(false, false)]
     public void DomainUpDown_UpdateEditText_InvokeEmpty_Success(bool userEdit, bool changingText)
     {
-        using SubDomainUpDown control = new()
-        {
-            UserEdit = userEdit,
-            ChangingText = changingText
-        };
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.UserEdit = userEdit;
+        _sub.ChangingText = changingText;
+
+        _sub.UpdateEditText();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Call again.
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.UpdateEditText();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -1346,24 +1296,23 @@ public void DomainUpDown_UpdateEditText_InvokeEmpty_Success(bool userEdit, bool
     [InlineData(false, false)]
     public void DomainUpDown_UpdateEditText_InvokeNotEmpty_Success(bool userEdit, bool changingText)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        control.UserEdit = userEdit;
-        control.ChangingText = changingText;
-
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.Items.Add("Item1");
+        _sub.Items.Add("Item2");
+        _sub.UserEdit = userEdit;
+        _sub.ChangingText = changingText;
+
+        _sub.UpdateEditText();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Call again.
-        control.UpdateEditText();
-        Assert.Empty(control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.UpdateEditText();
+        _sub.Text.Should().BeEmpty();
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
     }
 
     [WinFormsTheory]
@@ -1373,26 +1322,131 @@ public void DomainUpDown_UpdateEditText_InvokeNotEmpty_Success(bool userEdit, bo
     [InlineData(false, false)]
     public void DomainUpDown_UpdateEditText_InvokeNotEmptyWithSelection_Success(bool userEdit, bool changingText)
     {
-        using SubDomainUpDown control = new();
-        control.Items.Add("Item1");
-        control.Items.Add("Item2");
-        control.SelectedIndex = 0;
-        control.Text = "Text";
-        control.UserEdit = userEdit;
-        control.ChangingText = changingText;
-
-        control.UpdateEditText();
-        Assert.Equal("Item1", control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.Items.Add("Item1");
+        _sub.Items.Add("Item2");
+        _sub.SelectedIndex = 0;
+        _sub.Text = "Text";
+        _sub.UserEdit = userEdit;
+        _sub.ChangingText = changingText;
+
+        _sub.UpdateEditText();
+        _sub.Text.Should().Be("Item1");
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
 
         // Call again.
-        control.UpdateEditText();
-        Assert.Equal("Item1", control.Text);
-        Assert.False(control.UserEdit);
-        Assert.False(control.ChangingText);
-        Assert.False(control.IsHandleCreated);
+        _sub.UpdateEditText();
+        _sub.Text.Should().Be("Item1");
+        _sub.UserEdit.Should().BeFalse();
+        _sub.ChangingText.Should().BeFalse();
+        _sub.IsHandleCreated.Should().BeFalse();
+    }
+
+    [WinFormsTheory]
+    [InlineData(0, 1, false)]
+    [InlineData(1, 2, false)]
+    [InlineData(2, 2, false)] 
+    [InlineData(2, 0, true)] 
+    public void DomainUpDown_DownButton_InvokeWithItems_ChangesSelectedIndex(int initialIndex, int expectedIndex, bool wrap)
+    {
+        _control.Items.AddRange(new string[] { "Item1", "Item2", "Item3" });
+
+        _control.SelectedIndex = initialIndex;
+        _control.Wrap = wrap;
+
+        _control.DownButton();
+
+        _control.SelectedIndex.Should().Be(expectedIndex);
+    }
+
+    [WinFormsTheory]
+    [InlineData(0, 2, false)]
+    [InlineData(1, 2, false)]
+    [InlineData(2, 2, false)] 
+    [InlineData(2, 1, true)] 
+    public void DomainUpDown_DownButton_InvokeMultipleTimes_ChangesSelectedIndex(int initialIndex, int expectedIndex, bool wrap)
+    {
+        _control.Items.AddRange(new string[] { "Item1", "Item2", "Item3" });
+
+        _control.SelectedIndex = initialIndex;
+        _control.Wrap = wrap;
+
+        _control.DownButton();
+        _control.DownButton(); 
+
+        _control.SelectedIndex.Should().Be(expectedIndex);
+    }
+
+    [WinFormsTheory]
+    [InlineData(new string[] { "Item1", "Item2", "Item3" }, 1)]
+    [InlineData(new string[] { "ItemA", "ItemB", "ItemC", "ItemD" }, 3)]
+    public void DomainUpDown_ToString_Invoke_ReturnsExpected(string[] items, int selectedIndex)
+    {
+        _control.Items.Clear();
+        _control.Items.AddRange(items);
+        _control.SelectedIndex = selectedIndex;
+
+        string s = _control.ToString();
+
+        s.Should().Contain($"Items.Count: {items.Length}");
+        s.Should().Contain($"SelectedIndex: {selectedIndex}");
+    }
+
+    [WinFormsTheory]
+    [InlineData("Item1", 0)]
+    [InlineData("Item2", 1)]
+    public void DomainUpDown_UpButton_MatchFound(string text, int expectedIndex)
+    {
+        _control.Items.AddRange(new string[] { "Item1", "Item2", "Item3" });
+        _control.Text = text;
+        _control.UpButton();
+        _control.SelectedIndex.Should().Be(expectedIndex);
+    }
+
+    [WinFormsFact]
+    public void DomainUpDown_UpButton_NoMatchFound()
+    {
+        _control.Text = "NoSuchItem";
+        _control.UpButton();
+        _control.SelectedIndex.Should().Be(-1);
+    }
+
+    [WinFormsFact]
+    public void DomainUpDown_UpButton_DecrementSelectedIndex()
+    {
+        _control.Items.AddRange(new string[] { "Item1", "Item2", "Item3" });
+        _control.SelectedIndex = 2;
+        _control.UpButton();
+        _control.SelectedIndex.Should().Be(1);
+    }
+
+    [WinFormsFact]
+    public void DomainUpDown_UpButton_SelectedIndexAtStart_NoWrap()
+    {
+        _control.Items.AddRange(new string[] { "Item1", "Item2", "Item3" });
+        _control.SelectedIndex = 0;
+        _control.Wrap = false;
+        _control.UpButton();
+        _control.SelectedIndex.Should().Be(0);
+    }
+
+    [WinFormsFact]
+    public void DomainUpDown_UpButton_SelectedIndexAtStart_Wrap()
+    {
+        _control.Items.AddRange(new string[] { "Item1", "Item2", "Item3" });
+        _control.SelectedIndex = 0;
+        _control.Wrap = true;
+        _control.UpButton();
+        _control.SelectedIndex.Should().Be(2);
+    }
+
+    [WinFormsFact]
+    public void DomainUpDown_UpButton_EmptyItems()
+    {
+        _control.Items.Clear();
+        _control.UpButton();
+        _control.SelectedIndex.Should().Be(-1);
     }
 
     public class SubDomainUpDown : DomainUpDown